liveresource 2.0.0

data/old/benchmark/attribute_benchmark.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'benchmark_helper')
+
+class Resource
+  include LiveResource::Attribute
+  
+  remote_accessor :attribute
+  
+  def initialize
+    self.namespace = 'test'
+  end
+end
+
+class AttributeTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+  end
+
+  def run_with_threads(n_threads, n_total, &block)
+    threads = []
+
+    n_threads.times do
+      threads << Thread.new do
+        (n_total / n_threads).times { block.call }
+      end
+    end
+
+    threads.each { |t| t.join }
+  end
+
+  def test_attribute_performance
+    resource = Resource.new
+    n = 10000
+    
+    puts "Attribute get/set performance".title
+
+    Benchmark.bm do |x|
+      x.report("attr read (n=#{n})".pad) do
+        n.times { resource.attribute }
+      end
+
+      x.report("attr write (n=#{n})".pad) do
+        n.times { resource.attribute = 1 }
+      end      
+      
+      [1, 5, 10].each do |threads|
+        x.report("attr read (n=#{n}, #{threads} threads):".pad) do
+          run_with_threads(threads, n) { resource.attribute }
+        end
+      
+        x.report("attr write (n=#{n}, #{threads} threads):".pad) do
+          run_with_threads(threads, n) { resource.attribute = 1 }
+        end
+      end
+    end
+
+    assert true
+  end
+end

data/old/benchmark/thread_benchmark.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), 'benchmark_helper')
+
+class Supervisor
+  def main(total_jobs, max_workers)
+    redis = Redis.new
+    mutex = Mutex.new
+    workers = 0
+    
+    # Very roughly simulate having a pool of worker threads.
+    loop do
+      return if (redis.llen("results") == total_jobs)
+
+      Thread.pass while (mutex.synchronize { workers >= max_workers })
+      
+      Thread.new do
+        mutex.synchronize { workers += 1 }
+        # puts "Doing work (#{workers} workers)"
+        Worker.new.work(1)
+        mutex.synchronize { workers -= 1 }
+      end
+    end
+  end
+end
+
+class Worker
+  def work(loops)
+    redis = Redis.new
+    
+    loops.times do
+      job = redis.brpop "work", 0      
+      redis.lpush "results", job
+    end
+  end
+end
+
+class ThreadTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+  end
+  
+  def run_single_thread(jobs)
+    redis = Redis.new
+    
+    jobs.times do
+      redis.lpush "work", "foo"
+    end
+    
+    thread = Thread.new do
+      Worker.new.work(jobs)
+    end
+    
+    thread.join
+  end
+  
+  def run_thread_spawn_on_demand(jobs, threads)
+    redis = Redis.new
+    
+    jobs.times do
+      redis.lpush "work", "foo"
+    end
+
+    Supervisor.new.main(jobs, threads)
+  end
+  
+  def test_thread_performance
+    n = 10000
+    threads = 10
+    
+    puts "Redis push/pop performance, single thread vs. multi".title
+   
+    # Test which is faster: run one thread sitting on Redis vs. many 
+    # threads (one per job) dogpiling on Redis. That is, is the cost
+    # of spawning one thread per job more expensive than the IO to
+    # Redis? (On my machine, thread pool is nearly 4x faster. -jdc)
+    Benchmark.bm do |x|
+      x.report("single thread (n=#{n}):".pad) do
+        run_single_thread(n)
+      end
+      
+      [1, 2, 5, 10].each do |threads|
+        x.report("thread pool (n=#{n}, #{threads} threads):".pad) do
+          run_thread_spawn_on_demand(n, threads)
+        end
+      end
+    end
+    
+    assert true
+  end
+end

data/old/examples/attribute.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'lib/live_resource'
+
+class FavoriteColorPublisher
+  include LiveResource::Attribute
+
+  remote_writer :favorite
+end
+
+publisher = FavoriteColorPublisher.new
+publisher.namespace = "color"
+publisher.favorite = "blue"
+
+class FavoriteColor
+  include LiveResource::Attribute
+
+  remote_reader :favorite
+end
+
+reader = FavoriteColor.new
+reader.namespace = "color"
+puts reader.favorite # --> "blue"

data/old/examples/attribute_rmw.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'lib/live_resource'
+
+class FavoriteColorPublisher
+  include LiveResource::Attribute
+
+  remote_accessor :favorite
+
+  # Update favorite color to anything except the currently-published
+  # favorite.
+  def update_favorite
+    colors = ['red', 'blue', 'green']
+
+    remote_modify(:favorite) do |current_favorite|
+      colors.delete(current_favorite)
+
+      # Value of block will become the new value of the attribute.
+      colors.shuffle.first
+    end
+  end
+end
+
+color = FavoriteColorPublisher.new
+color.namespace = "color"
+color.favorite = "blue"
+
+10.times do
+  puts "Current fave: #{color.favorite}"
+  color.update_favorite
+end

data/old/examples/attribute_subscriber.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'lib/live_resource'
+
+class FavoriteColorPublisher
+  include LiveResource::Attribute
+
+  remote_writer :favorite
+end
+
+publisher = FavoriteColorPublisher.new
+publisher.namespace = "color"
+publisher.favorite = "blue"
+
+class FavoriteColorSubscriber
+  include LiveResource::Subscriber
+
+  remote_subscription :favorite
+
+  def favorite(new_favorite)
+    puts "Publisher changed its favorite to #{new_favorite}"
+  end
+end
+
+subscriber = FavoriteColorSubscriber.new
+subscriber.namespace = "color"
+subscriber.subscribe # Spawns thread
+
+# Publisher object from the "Attribute" section above.
+publisher.favorite = "red"
+publisher.favorite = "green"
+
+subscriber.unsubscribe

data/old/examples/method_provider_sleep.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'lib/live_resource'
+
+class Server
+  include LiveResource::MethodProvider
+
+  remote_method :divide
+
+  def divide(dividend, divisor)
+    raise ArgumentError.new("cannot divide by zero") if divisor == 0
+    
+    dividend / divisor
+  end
+end
+
+s = Server.new
+s.namespace = "math"
+s.logger.level = Logger::INFO
+
+Signal.trap("INT") { s.stop_method_dispatcher }
+
+s.start_method_dispatcher.join

data/old/examples/methods.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'lib/live_resource'
+
+class Server
+  include LiveResource::MethodProvider
+
+  remote_method :divide
+
+  def divide(dividend, divisor)
+    raise ArgumentError.new("cannot divide by zero") if divisor == 0
+    
+    dividend / divisor
+  end
+end
+
+class Client
+  include LiveResource::MethodSender
+  
+  def fancy_process(a, b)
+    begin
+      puts remote_send :divide, a, b
+    rescue ArgumentError => e
+      puts "oops, I messed up: #{e}"
+    end
+  end
+end
+
+s = Server.new
+s.namespace = "math"
+s.start_method_dispatcher
+
+c = Client.new
+c.namespace = "math"
+c.fancy_process(10, 5)
+c.fancy_process(1, 0)
+
+s.stop_method_dispatcher

data/old/lib/live_resource/subscriber.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), 'common')
+
+module LiveResource
+  module Subscriber
+    include LiveResource::Common
+    
+    UNSUBSCRIBE_KEY = :unsubscribe_key
+
+    def subscribe
+      ready = false
+      subscriptions = self.class.instance_variable_get :@subscriptions
+      channels = [UNSUBSCRIBE_KEY] + subscriptions.keys
+
+      @thread = Thread.new do
+        redis_space.subscribe(channels) do |on|
+          on.subscribe do |key, total|
+            debug "Subscribed to #{key} (#{total} subscriptions)"
+
+            if (channels.length == total)
+              debug "Subscriber ready"
+              ready = true
+            end
+          end
+
+          on.message do |key, new_value|
+            # Need to strip namespace from key; callbacks were registered
+            # before namespace was known (at initialize).
+            namespace_length = @namespace.length + 1 # Include '.' separator
+            key = key.to_s
+            key = key[namespace_length, key.length - namespace_length]
+            key = key.to_sym
+            
+            # De-serialize value
+            new_value = new_value.nil? ? nil : YAML::load(new_value)
+
+            debug "#{key.inspect} changed value to #{new_value.inspect}"
+            
+            if key.to_s.end_with? UNSUBSCRIBE_KEY.to_s
+              redis_space.unsubscribe
+              next
+            end
+            
+            m = subscriptions[key]
+            
+            if m.nil?
+              warn "Received subscription update for unknown key #{key}"
+              next
+            end
+
+            # Need to send method on new thread, as that method may do
+            # additional LiveResource/Redis operations, and this thread's
+            # Redis client is in subscribe mode.
+            Thread.new { send m, new_value }
+          end
+
+          on.unsubscribe do |key, total|
+            debug "Unsubscribed from #{key} (#{total} subscriptions)"
+          end
+
+          debug "Subscriber thread started"
+        end
+
+        debug "Subscriber thread done"
+      end
+
+      Thread.pass while !ready
+
+      @thread
+    end
+
+    def unsubscribe
+      # Need to publish on secondary RedisSpace because the first one is
+      # blocked waiting for subscription updates.
+      @rs_secondary = redis_space.clone
+      @rs_secondary.publish UNSUBSCRIBE_KEY, true
+      @thread.join
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def remote_subscription(attribute, method = nil)
+        @subscriptions ||= Hash.new
+
+        if @subscriptions[attribute]
+          throw ArgumentError, "Subscription callback already defined for attribute #{attribute}"
+        end
+        
+        # If method isn't specified, assume it matches the attribute name.
+        method ||= attribute
+        
+        @subscriptions[attribute.to_sym] = method.to_sym
+      end
+    end
+  end
+end

data/old/redis_test.rb

@@ -0,0 +1,127 @@
+require_relative 'test_helper'
+
+class FancyClass
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+end
+
+class RedisClientTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+  end
+
+  def test_global_redis_space
+    assert_equal LiveResource::RedisClient, LiveResource::redis.class
+  end
+
+  # def test_method_get_set_with_same_key
+  #   rc = mock()
+  #   rc.expects :attribute_set, "--- 123\n...\n"
+  # 
+  # 
+  #   logger = Logger.new(STDOUT)
+  #   logger.level = Logger::WARN
+  #   r = LiveResource::Client.new('test', logger)
+  # 
+  #   # Set with same token, differing keys
+  #   rs.method_set 123, 'key 1', 'value 1'
+  #   rs.method_set 123, 'key 2', FancyClass.new(42)
+  # 
+  #   assert_equal 'value 1', rs.method_get(123, 'key 1')
+  #   assert_equal 42, rs.method_get(123, 'key 2').value
+  # end
+  # 
+  # def test_method_tokens_independent
+  #   rs = LiveResource::RedisSpace.new('test')
+  #   
+  #   # Set several value, same keys but different tokens
+  #   rs.method_set 1, 'key', 'value 1'
+  #   rs.method_set 2, 'key', 'value 2'
+  #   rs.method_set 3, 'key', 'value 3'
+  #   
+  #   assert_equal 'value 1', rs.method_get(1, 'key')
+  #   assert_equal 'value 2', rs.method_get(2, 'key')
+  #   assert_equal 'value 3', rs.method_get(3, 'key')
+  # end
+  # 
+  # def test_method_set_exclusive
+  #   rs = LiveResource::RedisSpace.new('test')
+  # 
+  #   assert_equal true, rs.method_set_exclusive(1, 'key', 'value 1')
+  #   assert_equal false, rs.method_set_exclusive(1, 'key', 'value 2')
+  # end
+  # 
+  # def test_method_push_pop_simple
+  #   rs = LiveResource::RedisSpace.new('test')
+  #   assert_equal 0, Redis.new.dbsize
+  #   
+  #   rs.method_push '1'
+  #   assert_equal 1, Redis.new.dbsize
+  # 
+  #   token = rs.method_wait
+  #   assert_equal '1', token
+  #   
+  #   rs.method_done token
+  #   assert_equal 0, Redis.new.dbsize    
+  # end
+  # 
+  # def test_method_push_pop_multiple
+  #   rs = LiveResource::RedisSpace.new('test')
+  #   assert_equal 0, Redis.new.dbsize
+  #   
+  #   rs.method_push '1'
+  #   rs.method_push '2'
+  #   rs.method_push '3'
+  #   
+  #   assert_equal ['3', '2', '1'], rs.method_tokens_waiting
+  #   assert_equal [], rs.method_tokens_in_progress
+  # 
+  #   assert_equal '1', rs.method_wait
+  #   assert_equal '2', rs.method_wait
+  #   assert_equal '3', rs.method_wait
+  # 
+  #   assert_equal [], rs.method_tokens_waiting
+  #   assert_equal ['3', '2', '1'], rs.method_tokens_in_progress
+  # 
+  #   # Redis should have one key here (the methods_in_progress list)
+  #   assert_equal 1, Redis.new.dbsize
+  # 
+  #   # Now start marking methods done; after the last one, the key 
+  #   # count should go down to zero.
+  #   rs.method_done '1'
+  #   assert_equal 1, Redis.new.dbsize
+  #   rs.method_done '2'
+  #   assert_equal 1, Redis.new.dbsize
+  #   rs.method_done '3'
+  #   assert_equal 0, Redis.new.dbsize    
+  # end
+  # 
+  # def test_serializes_exceptions_properly
+  #   rs = LiveResource::RedisSpace.new('test')
+  # 
+  #   rs.method_set('1', 'key', 'value') # just need something there
+  #   rs.result_set('1', RuntimeError.new('foo'))    
+  #   result = rs.result_get '1'
+  #   
+  #   assert_equal RuntimeError, result.class
+  #   assert_equal 'foo', result.message
+  # end
+  # 
+  # def test_find_token_in_lists
+  #   r = Redis.new
+  #   rs = LiveResource::RedisSpace.new('test')
+  # 
+  #   r.lpush('test.methods', '1')
+  #   r.lpush('test.methods_in_progress', '2')
+  #   r.lpush('test.results.3', 'result')
+  #   
+  #   assert_equal :methods, rs.find_token('1')
+  #   assert_equal :methods_in_progress, rs.find_token('2')
+  #   assert_equal :results, rs.find_token('3')
+  #   assert_equal nil, rs.find_token('4')
+  # end  
+end
+