liveresource 2.0.0

data/test/method_params_test.rb

@@ -0,0 +1,81 @@
+require_relative 'test_helper'
+
+class ParamsTest < Test::Unit::TestCase
+  class ParamsClass
+    include LiveResource::Resource
+
+    remote_reader :name
+    remote_reader :age
+
+    resource_name :name
+    resource_class :params_class
+
+    def initialize(name, age)
+      remote_attribute_write(:name, name)
+      remote_attribute_write(:age, age)
+    end
+
+    def no_params_method
+      self.age
+    end
+
+    def fixed_params_method(arg1, arg2)
+      arg1 + arg2
+    end
+
+    def splat_params_method(*params)
+      params.length
+    end
+
+    def mixed_params_method(arg1, arg2, *params)
+      result = arg1 + arg2
+      params.each do |param|
+        result = result + param
+      end
+      result
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+
+    LiveResource::RedisClient.logger.level = Logger::INFO
+
+    # Class resources
+    LiveResource::register ParamsClass
+
+    @test_class = LiveResource::find(:params_class)
+    @test_instance = @test_class.new("bob", 42)
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_no_params_method
+    assert_equal 42, @test_instance.no_params_method
+    assert_raise(ArgumentError) { @test_instance.no_params_method("foo") }
+  end
+
+  def test_fixed_params_method
+    assert_equal 13, @test_instance.fixed_params_method(6, 7)
+    assert_raise(ArgumentError) { @test_instance.fixed_params_method }
+    assert_raise(ArgumentError) { @test_instance.fixed_params_method(6, 7, 8) }
+  end
+
+  def test_splat_params_method
+    assert_equal 0, @test_instance.splat_params_method
+    assert_equal 1, @test_instance.splat_params_method("foo")
+    assert_equal 2, @test_instance.splat_params_method("foo", "bar")
+    assert_equal 3, @test_instance.splat_params_method("foo", "bar", "baz")
+  end
+
+  def test_mixed_params_method
+    assert_equal 3, @test_instance.mixed_params_method(1, 2)
+    assert_equal 6, @test_instance.mixed_params_method(1, 2, 3)
+    assert_equal 10, @test_instance.mixed_params_method(1, 2, 3, 4)
+
+    assert_raise(ArgumentError) { @test_instance.mixed_params_method }
+    assert_raise(ArgumentError) { @test_instance.mixed_params_method(1) }
+  end
+end

data/test/method_routing_test.rb

@@ -0,0 +1,59 @@
+require_relative 'test_helper'
+
+class MethodRoutingTest < Test::Unit::TestCase
+  class Class1
+    include LiveResource::Resource
+
+    resource_class :class_1
+    resource_name :object_id
+
+    def method1
+      [1]
+    end
+  end
+
+  class Class2
+    include LiveResource::Resource
+
+    resource_class :class_2
+    resource_name :object_id
+
+    def method2(i)
+      [i, 2]
+    end
+  end
+
+  class Class3
+    include LiveResource::Resource
+
+    resource_class :class_3
+    resource_name :object_id
+
+    def method3(i, j)
+      [i, j, 3]
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+    Class1.new
+    Class2.new
+    Class3.new
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_create_method
+    m = LiveResource::RemoteMethod.new(:method => :method1)
+    c1 = LiveResource::any(:class_1)
+    c2 = LiveResource::any(:class_2)
+    c3 = LiveResource::any(:class_3)
+
+    m.add_destination(c2, :method2, [])
+    m.add_destination(c3, :method3, [])
+
+    assert_equal [1, 2, 3], c1.wait_for_done(c1.remote_send(m))
+  end
+end

data/test/multiple_class_test.rb

@@ -0,0 +1,47 @@
+require_relative 'test_helper'
+
+class ClassMethodTest < Test::Unit::TestCase
+  class Class1
+    include LiveResource::Resource
+
+    resource_class :class_1
+    resource_name :object_id
+
+    def self.class_method_1
+      "42"
+    end
+  end
+
+  class Class2
+    include LiveResource::Resource
+
+    resource_class :class_2
+    resource_name :object_id
+
+    def self.class_method_2
+      "foo"
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+
+    LiveResource::register Class1
+    LiveResource::register Class2
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_classes_dont_conflict
+    c1 = LiveResource::find(:class_1)
+    c2 = LiveResource::find(:class_2)
+
+    assert_equal true,  c1.respond_to?(:class_method_1)
+    assert_equal false, c1.respond_to?(:class_method_2)
+
+    assert_equal true,  c2.respond_to?(:class_method_2)
+    assert_equal false, c2.respond_to?(:class_method_1)
+  end
+end

data/test/new_api_DISABLED.rb

@@ -0,0 +1,127 @@
+require_relative 'test_helper'
+
+class VolumeResource
+  include LiveResource::Resource
+  
+  # Class type: "volume-class"
+  # Class instance name: "volume-class.{hostname}.{pid}"
+  # Instance type: "volume"
+  # Instance name: "volume.my_volume_name"
+  resource_type :volume
+  resource_name "<%= self.name %>"
+
+  # Attribute and method declarations stay the same.
+  remote_attribute :name, :online
+  remote_method :start, :stop
+
+  # LR will always provide class-namespace methods like all() and 
+  # find(&block), implemented on the client side. If any class
+  # methods are provided, then we'll also start a class-level method
+  # dispatcher.
+  remote_class_method :create_volume
+
+  def initialize(name)
+    @name = name
+    @online = false
+    
+    LiveResource::Worker::register(self)
+  end
+  
+  def start
+    unless @online
+      info "starting"
+      @online = true
+    end
+    
+    @online
+  end
+  
+  def stop
+    if @online
+      info "stopping"
+      @online = false
+    end
+    
+    @online
+  end
+  
+  def self.create_volume(name)
+    info "creating new volume #{name}"
+    VolumeResource.new(name)
+  end
+end
+
+class ModuleTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+
+    LiveResource::Worker::register_class(VolumeResource)
+
+    # Run method dispatchers in separate threads; use LR::run to 
+    # block while they run (e.g., for a dedicated worker process).
+    # Each instance will still have its own thread regardless.
+    LiveResource::Worker::start
+	end
+	
+	def teardown
+	  # Stop and join method dispatchers
+	  LiveResource::Worker::stop
+  end
+	
+	def test_foo
+	  # Resource finders:
+	  #   LiveResource::all(type)      -> [array]
+	  #   LiveResource::find(type)     -> class resource
+	  #   LiveResource::find(t,name)   -> resource matching name
+	  #   LiveResource::find(t,&block) -> resource matching condition
+	  #   LiveResource::first(type)    -> first resource
+	  #   LiveResource::any(type)      -> picks one randomly
+
+    # Find on type alone gives the class resource.
+	  vc = LiveResource::find(:volume)
+	
+	  # Sync class-level method call
+	  vc.create_volume "foo"
+	  
+	  # Async class-level call with future
+	  done = vc.create_volume!?("bar")
+	  
+	  # Wait for complete
+	  done.value
+    
+    # Find by resource type and name, in this case name is the same
+    # as volume name. (See resource_name declaration above.)
+    v1 = LiveResource::find(:volume, "foo")
+    
+    # Find by resource matching type and block.
+    v2 = LiveResource::find(:volume) { |v| v.name == "bar" }
+	
+	  # Attribute read: only consults Redis
+	  assert_equal false, v1.online
+	  
+	  # Syncronous method call, blocks until complete
+	  assert_equal true, v1.start
+    assert_equal true, v1.online
+
+    # Async method call
+    v2.start!
+    10.times { Thread.pass }
+    assert_equal true, v2.online
+
+    # Async method with future
+    done = []
+    
+    # Note: each applies to instances, excluding the class instance.
+    LiveResource::each(:volume) { |v| done << v.stop!? }
+    
+    begin
+      done.each { |d| d.value }
+    rescue e
+      # Log error and continue waiting for others to complete.
+      nil
+    end
+    
+    ## TODO: wrap the above construct in one method that takes one
+    # block for the action, another for completion action.
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+require 'thread'
+require 'mocha'
+require 'pp'
+
+require_relative '../lib/live_resource'
+
+Thread.abort_on_exception = true

data/test/volume_create_DISABLED.rb

@@ -0,0 +1,74 @@
+require_relative 'test_helper'
+
+class VolumeResource
+  include LiveResource::Resource
+  
+  resource_type :volume
+  resource_name "<%= self.name %>"
+
+  remote_attribute :name, :status
+  remote_method :start, :stop
+  
+  # Internal-only volume create methods
+  remote_method :stage1_create_gluster_config
+  remote_method :stage2_create_gluster_config_done
+
+  # TODO:
+  # Implicit in declaring remote_class_method :new
+  # class << self
+  #   alias_method object_new new
+  # end
+  #
+  remote_class_method :new
+
+  def initialize(name)
+    @name = name
+    
+    LiveResource::Worker::register(self)
+  end
+  
+  def self.new(name)
+    info "creating new volume #{name}"
+    v = VolumeResource.object_new(name)
+
+    v.status = :creating    
+    v.stage1_create_gluster_config!
+  end
+  
+  def stage1_create_gluster_config
+    params = { } # stuff here that Gluster needs
+
+    # This builds up a state object that's returned to the method dispatcher.
+    # - Instead of reply, this is a forward
+    # - It goes to a :gluster instance
+    # - The new method and params are wrapped up in same way as a new method call
+    # - There's a hidden parameter which specifies the continuation method
+    LiveResource::any(:gluster).forward(:create_config, self).continue_to(:stage2_create_gluster_config_done)
+  end
+  
+  # Return values from remote methods:
+  # - Explicit reply
+  # - Forward to another actor
+  # - Something else, that gets treated as a reply
+  #
+  # Method dispatcher may already have state for continuing to another method.
+  
+  def stage2_create_gluster_config_done
+    @status = :stopped
+  end
+end
+
+class GlusterResource
+  include LiveResource::Resource
+  
+  resource_type :gluster
+  resource_name "<%= self.hostname %>"
+  
+  remote_method :create_config
+  
+  def create_config(volume)
+    # do gluster stuff here to set up volume
+
+    nil # No params necessary
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: liveresource
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Spectra Logic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Remote-callable attributes and methods for IPC and cluster use.
+email: public@joshcarter.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- BSDL
+- COPYING
+- GPL
+- README.md
+- Rakefile
+- benchmark/benchmark_helper.rb
+- benchmark/method_benchmark.rb
+- lib/live_resource.rb
+- lib/live_resource/attributes.rb
+- lib/live_resource/declarations.rb
+- lib/live_resource/finders.rb
+- lib/live_resource/log_helper.rb
+- lib/live_resource/methods.rb
+- lib/live_resource/methods/dispatcher.rb
+- lib/live_resource/methods/forward.rb
+- lib/live_resource/methods/future.rb
+- lib/live_resource/methods/method.rb
+- lib/live_resource/methods/token.rb
+- lib/live_resource/redis_client.rb
+- lib/live_resource/redis_client/attributes.rb
+- lib/live_resource/redis_client/methods.rb
+- lib/live_resource/redis_client/registration.rb
+- lib/live_resource/resource.rb
+- lib/live_resource/resource_proxy.rb
+- old/benchmark/attribute_benchmark.rb
+- old/benchmark/thread_benchmark.rb
+- old/examples/attribute.rb
+- old/examples/attribute_rmw.rb
+- old/examples/attribute_subscriber.rb
+- old/examples/method_provider_sleep.rb
+- old/examples/methods.rb
+- old/lib/live_resource/subscriber.rb
+- old/redis_test.rb
+- old/state_publisher_test.rb
+- old/test/attribute_modify_test.rb
+- old/test/attribute_options_test.rb
+- old/test/attribute_subscriber_test.rb
+- old/test/composite_resource_test.rb
+- old/test/method_sender_test.rb
+- old/test/redis_api_test.rb
+- old/test/simple_attribute_test.rb
+- test/attribute_test.rb
+- test/declarations_test.rb
+- test/logger_test.rb
+- test/method_call_test.rb
+- test/method_forward_continue_test.rb
+- test/method_params_test.rb
+- test/method_routing_test.rb
+- test/multiple_class_test.rb
+- test/new_api_DISABLED.rb
+- test/test_helper.rb
+- test/volume_create_DISABLED.rb
+homepage: https://github.com/joshcarter/liveresource
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Live Resource
+test_files: []