liveresource 2.0.0

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rake/testtask'
+require 'yard'
+
+desc "Default Task"
+task :default => [:test]
+
+Rake::TestTask.new :test do |test|
+  test.verbose = false
+  test.test_files = ['test/*_test.rb'].sort
+end
+
+Rake::TestTask.new :benchmark do |benchmark|
+  benchmark.verbose = false
+	#  benchmark.options = '--verbose=s'
+  benchmark.test_files = ['benchmark/*_benchmark.rb']
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+end
+
+task :clean do
+  FileUtils.rm_rf 'pkg'
+end
+
+gem_spec = Gem::Specification.new do |spec|
+  spec.name = 'liveresource'
+  spec.summary = 'Live Resource'
+  spec.version = '2.0.0'
+  spec.author = 'Spectra Logic'
+	spec.email = 'public@joshcarter.com'
+	spec.homepage = 'https://github.com/joshcarter/liveresource'
+	spec.description = 'Remote-callable attributes and methods for ' \
+    'IPC and cluster use.'
+
+  spec.files = `git ls-files`.split("\n")
+
+  spec.add_dependency 'redis'
+	spec.add_development_dependency 'yard'
+end
+
+gem = Gem::PackageTask.new(gem_spec) do |pkg|
+  pkg.need_tar = false
+  pkg.need_zip = false
+end

data/benchmark/benchmark_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'test/unit'
+require 'thread'
+require 'pp'
+require 'benchmark'
+
+require_relative '../lib/live_resource'
+
+Thread.abort_on_exception = true
+
+class String
+  def pad(pad_to = 70)
+    self.ljust(pad_to)
+  end
+
+  def title
+    "*\n* #{self}\n*\n"
+  end
+end

data/benchmark/method_benchmark.rb

@@ -0,0 +1,94 @@
+require_relative 'benchmark_helper'
+
+class Server
+  include LiveResource::Resource
+
+  resource_class :server
+  resource_name :object_id
+
+  def test_method
+    42
+  end
+end
+
+class MethodTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+    LiveResource::register Server.new
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_sync_method_performance
+    n = 1000
+
+    puts "Synchronous method call performance".title
+
+    [1, 5, 10].each do |threads|
+      b = Benchmark.measure do
+        run_sync(n, threads)
+      end
+
+      puts ("n=#{n}, #{threads} threads: #{b.to_s.strip} " +
+      sprintf("%.0f m/sec", n / b.total)).pad
+    end
+
+    assert true
+  end
+
+  def test_async_method_performance
+    n = 1000
+
+    puts "Asynchronous method call performance".title
+
+    [1, 10, 100].each do |batch_size|
+      b = Benchmark.measure do
+        run_async(n, batch_size)
+      end
+
+      puts ("n=#{n}, batches of #{batch_size}: #{b.to_s.strip} " +
+      sprintf("%.0f m/sec", n / b.total)).pad
+    end
+
+    assert true
+  end
+
+  def run_sync(n, n_threads)
+    threads = []
+
+    n_threads.times do
+      threads << Thread.new do
+        server = LiveResource::any(:server)
+
+        (n / n_threads).times { server.test_method }
+      end
+    end
+
+    threads.each { |t| t.join }
+  end
+
+  def run_async(n, batch_size)
+    server = LiveResource::any(:server)
+    futures = Queue.new
+
+    # Calls
+    send_thread = Thread.new do
+      n.times do
+        Thread.pass while (futures.length >= batch_size)
+
+        futures << server.test_method?
+      end
+    end
+
+    # Results
+    n.times do
+      Thread.pass while futures.empty?
+
+      futures.pop.value
+    end
+
+    send_thread.join
+  end
+end

data/lib/live_resource.rb

@@ -0,0 +1,66 @@
+require_relative 'live_resource/resource'
+require 'set'
+
+# LiveResource is a framework for coordinating processes and status
+# within a distributed system. Consult the documention for
+# LiveResource::Resource for attribute and method providers,
+# LiveResource::Finders for discovering resources, and
+# LiveResource::ResourceProxy for using resources.
+module LiveResource
+  # Register the resource, allowing its discovery and methods to be
+  # called on it. This method will block until the resource is fully
+  # registered and its method dispatcher is running.
+  #
+  # @param resource [LiveResource::Resource] the object to register
+  def self.register(resource)
+    # puts "registering #{resource.to_s}"
+
+    @@resources ||= Set.new
+    @@resources << resource
+
+    resource.start
+  end
+
+  # Unregister the resource, removing it from discovery and stopping
+  # its method dispatcher. This method will block until the method
+  # dispatcher is stopped.
+  #
+  # @param resource [LiveResource::Resource] the object to unregister
+  def self.unregister(resource)
+    # puts "unregistering #{resource.to_s}"
+
+    resource.stop
+
+    @@resources.delete resource
+  end
+
+  # Start all resources. Usually not needed since registering a
+  # resource automatically starts it; however if you stopped
+  # LiveResource manually, this will let you re-start all registered
+  # resources.
+  def self.start
+    @@resources.each do |resource|
+      resource.start
+    end
+  end
+
+  # Stop all resources, preventing methods from being called on them.
+  def self.stop
+    @@resources.each do |resource|
+      resource.stop
+    end
+  end
+
+  # Run LiveResource until the exit_signal (default=SIGINT) is recevied.
+  # Optionally invoke the exit callback before exiting.
+  def self.run(exit_signal="INT", &exit_cb)
+    Signal.trap(exit_signal) do
+      self.stop
+      yield if exit_cb
+      exit
+    end
+
+    # Put this thread to sleep
+    sleep
+  end
+end

data/lib/live_resource/attributes.rb

@@ -0,0 +1,77 @@
+module LiveResource
+  module Attributes
+    def redis
+      @_redis ||= RedisClient.new(resource_class, resource_name)
+    end
+
+    def remote_attributes
+      if self.is_a? Class
+        []
+      else
+        self.class.remote_instance_attributes
+      end
+    end
+
+    def remote_attribute_read(key, options = {})
+      redis.attribute_read(key, options)
+    end
+
+    def remote_attribute_write(key, value, options = {})
+      if (key.to_sym == self.class.resource_name_attr) and !self.is_a?(Class)
+        @_redis = RedisClient.new(resource_class, value)
+      end
+
+      redis.attribute_write(key, value, options)
+    end
+
+    # Write a new value to an attribute if it doesn't exist yet.
+    def remote_attribute_writenx(key, value)
+      remote_attribute_write(key, value, no_overwrite: true)
+    end
+
+    # Modify an attribute or set of attributes based on the current value(s).
+    # Uses the optimistic locking mechanism provided by Redis WATCH/MULTI/EXEC
+    # transactions.
+    #
+    # The user passes in the a block which will be used to update the attribute(s).
+    # Since the block may need to be replayed, the user should not update any
+    # external state that relies on the block executing only once.
+    def remote_attribute_modify(*attributes, &block)
+      invalid_attrs = attributes - redis.registered_attributes
+      unless invalid_attrs.empty?
+        raise ArgumentError.new("remote_modify: no such attribute(s) '#{invalid_attrs}'")
+      end
+
+      unless block
+        raise ArgumentError.new("remote_modify requires a block")
+      end
+
+      # Optimistic locking implemented along the lines of:
+      #   http://redis.io/topics/transactions
+      loop do
+        # Gather up the attributes and their new values
+        mods = attributes.map do |a|
+          # Watch/get the value
+          redis.attribute_watch(a)
+          v = redis.attribute_read(a)
+
+          # Block modifies the value
+          v = block.call(a, v)
+          [a, v]
+        end
+
+        # Start the transaction
+        redis.multi
+
+        mods.each do |mod|
+          # Set to new value; if ok, we're done.
+          redis.attribute_write(mod[0], mod[1])
+        end
+
+        # Attempt to execute the transaction. Otherwise we'll loop and
+        # try again with the new value.
+        break if redis.exec
+      end
+    end
+  end
+end

data/lib/live_resource/declarations.rb

@@ -0,0 +1,200 @@
+require 'set'
+
+module LiveResource
+  module Declarations
+    def resource_name
+      # Getting resource name may be expensive, e.g. if it's coming
+      # from Redis. Cache so we don't re-fectch this resource's name
+      # more than once.
+      return @_cached_resource_name if @_cached_resource_name
+
+      # Class-level resource_name is an attribute we fetch to determine
+      # the instance's name
+      attr = self.class.resource_name_attr
+
+      if attr
+        @_cached_resource_name = self.send(attr)
+      else
+        raise "can't get resource name for #{self.class.to_s}"
+      end
+    end
+
+    def resource_class
+      self.class.instance_variable_get(:@_resource_class)
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        class << base
+          # Override the regular new routine with a custom new
+          # which auto-registers the resource.
+          alias :ruby_new :new
+
+          def new(*params)
+            obj = ruby_new(*params)
+            LiveResource::register obj
+            obj
+          end
+        end
+      end
+
+      # FIXME: comment this
+      def resource_name(attribute_name = nil)
+        if attribute_name
+          # Called from class definition to set the attribute from which we get a resource's name.
+          @_resource_name = attribute_name.to_sym
+        else
+          # Get the class-level resource name.
+          @_resource_class
+        end
+      end
+
+      # FIXME: comment this
+      def resource_class(class_name = nil)
+        if class_name
+          # Called from class definition to set the resource's class.
+          @_resource_class = class_name.to_sym
+        else
+          # Get the class-level resource class, which we'll always call :class.
+          :class
+        end
+      end
+
+      # Get the attribute which defines this resource's name. (For internal use only.)
+      def resource_name_attr
+        @_resource_name
+      end
+
+      # call-seq:
+      #   remote_reader :attr
+      #   remote_reader :attr, { :opt => val }
+      #   remote_reader :attr1, :attr2, :attr3
+      #
+      # Declare a remote attribute reader. A list of symbols is used
+      # to create multiple attribute readers.
+      def remote_reader(*params)
+        @_instance_attributes ||= Set.new
+        options = {}
+
+        # One symbol and one hash is treated as a reader with options;
+        # right now there are no reader options, so just pop them off.
+        if (params.length == 2) && (params.last.is_a? Hash)
+          options = params.pop
+        end
+
+        # Everything left in params should be a symbol (i.e., method name).
+        if params.find { |m| !m.is_a? Symbol }
+          raise ArgumentError.new("Invalid or ambiguous arguments to remote_reader: #{params.inspect}")
+        end
+
+        params.each do |m|
+          @_instance_attributes << m
+
+          define_method("#{m}") do
+            remote_attribute_read(m, options)
+          end
+        end
+      end
+
+      # call-seq:
+      #   remote_writer :attr
+      #   remote_writer :attr, { :opt => val }
+      #   remote_writer :attr1, :attr2, :attr3
+      #
+      # Declare a remote attribute writer. One or more symbols are
+      # used to declare writers with default options. This creates
+      # methods matching the symbols provided, e.g.:
+      #
+      #   remote_writer :attr   ->    def attr=(value) [...]
+      #
+      # One symbol and a hash is used to declare an attribute writer
+      # with options. Currently supported options:
+      #
+      # * :ttl (integer): time-to-live of attribute. After (TTL)
+      #   seconds, the value of the attribute returns to nil.
+      def remote_writer(*params)
+        @_instance_attributes ||= Set.new
+        options = {}
+
+        # One symbol and one hash is treated as a writer with options.
+        if (params.length == 2) && (params.last.is_a? Hash)
+          options = params.pop
+        end
+
+        # Everything left in params should be a symbol (i.e., method name).
+        if params.find { |m| !m.is_a? Symbol }
+          raise ArgumentError.new("Invalid or ambiguous arguments to remote_writer: #{params.inspect}")
+        end
+
+        params.each do |m|
+          @_instance_attributes << "#{m}=".to_sym
+
+          define_method("#{m}=") do |value|
+            remote_attribute_write(m, value, options)
+          end
+        end
+      end
+
+      # call-seq:
+      #   remote_accessor :attr
+      #   remote_accessor :attr, { :opt => val }
+      #   remote_accessor :attr1, :attr2, :attr3
+      #
+      # Declare remote attribute reader and writer. One or more symbols
+      # are used to declare multiple attributes, as in +remote_writer+.
+      # One symbol with a hash is used to declare an accessor with
+      # options; currently these options are only supported on the
+      # attribute write, and they are ignored on the attribute read.
+      def remote_accessor(*params)
+        remote_reader(*params)
+        remote_writer(*params)
+      end
+
+      def remote_instance_attributes
+        @_instance_attributes ||= Set.new
+        @_instance_attributes.to_a
+      end
+
+      # Remote-callable methods for an instance.
+      def remote_instance_methods
+        @_instance_methods ||= Set.new
+        @_instance_attributes ||= Set.new
+
+        # Remove all instance attributes, then fiter out private and
+        # protected methods.
+        (@_instance_methods - @_instance_attributes).find_all do |m|
+          if private_method_defined?(m) or protected_method_defined?(m)
+            nil
+          else
+            m
+          end
+        end
+      end
+
+      # Remote-callable methods for a resource class.
+      def remote_singleton_methods
+        @_singleton_methods ||= Set.new
+        c = singleton_class
+
+        # Filter out private and protected methods of the singleton class.
+        @_singleton_methods.find_all do |m|
+          if c.private_method_defined?(m) or c.protected_method_defined?(m)
+            nil
+          else
+            m
+          end
+        end
+      end
+
+      def method_added(m)
+        @_instance_methods ||= Set.new
+        @_instance_methods << m
+      end
+
+      def singleton_method_added(m)
+        @_singleton_methods ||= Set.new
+        @_singleton_methods << m
+      end
+    end
+  end
+end