lib/nanite/actor_registry.rb spec/actor_registry_spec.rb @@ -29,7 +29,8 @@ In your Nanites you can have any number of actor classes. These actors are like in Rails or Merb and this is where you implement your own custom functionality. An actor looks like: - class Foo < Nanite::Actor + class Foo + include Nanite::Actor expose :bar def bar(payload) "got payload: #{payload}" @@ -321,7 +322,7 @@ The easiest way to verify it is by starting two separate Erlang shells like this $ erl -sname fred (fred@odin)1> - $erl -sname bob + $ erl -sname bob (bob@odin)1> And then trying to 'ping' one from the other. In the 'fred' node you can do that like this: README.rdoc @@ -1,4 +1,6 @@ -class Rabbit < Nanite::Actor +class Rabbit + include Nanite::Actor + expose :add_user,:delete_user, :change_password, :list_users, :add_vhost, :delete_vhost, :list_vhosts, :map_user_vhost, :unmap_user_vhost, :list_user_vhosts, :list_vhost_users, examples/rabbitmqctl/actors/rabbit.rb @@ -1,4 +1,5 @@ -class RackWorker < Nanite::Actor +class RackWorker + include Nanite::Actor expose :call def initialize(app) examples/rack-worker/actors/rack_worker.rb @@ -1,6 +1,7 @@ # you can execute this nanite from the cli.rb command line example app -class Simple < Nanite::Actor +class Simple + include Nanite::Actor expose :echo, :time, :gems def echo(payload) examples/simpleagent/actors/simple.rb @@ -16,6 +16,7 @@ require 'nanite/daemonize' require 'nanite/job' require 'nanite/mapper' require 'nanite/actor' +require 'nanite/actor_registry' require 'nanite/streaming' require 'nanite/dispatcher' require 'nanite/agent' lib/nanite.rb @@ -1,61 +1,64 @@ module Nanite - class Actor - def self.default_prefix - to_s.to_const_path - end + # This mixin provides Nanite actor functionality. + # + # To use it simply include it your class containing the functionality to be exposed: + # + # class Foo + # include Nanite::Actor + # expose :bar + # + # def bar(payload) + # # ... + # end + # + # end + module Actor - def self.expose(*meths) - @exposed ||= [] - meths.each do |meth| - @exposed << meth + def self.included(base) + base.class_eval do + include Nanite::Actor::InstanceMethods + extend Nanite::Actor::ClassMethods + end # base.class_eval + end # self.included + + module ClassMethods + def default_prefix + to_s.to_const_path end - end - def self.provides_for(prefix) - return [] unless @exposed - @exposed.map {|meth| "/#{prefix}/#{meth}".squeeze('/')} - end - - def self.on_exception(proc = nil, &blk) - raise 'No callback provided for on_exception' unless proc || blk - if Nanite::Actor == self - raise 'Method name callbacks cannot be used on the Nanite::Actor superclass' if Symbol === proc || String === proc - @superclass_exception_callback = proc || blk - else - @instance_exception_callback = proc || blk + def expose(*meths) + @exposed ||= [] + meths.each do |meth| + @exposed << meth unless @exposed.include?(meth) + end end - end - - def self.superclass_exception_callback - @superclass_exception_callback - end - - def self.instance_exception_callback - @instance_exception_callback - end - end - - class ActorRegistry - attr_reader :actors, :log - def initialize(log) - @log = log - @actors = {} - end + def provides_for(prefix) + return [] unless @exposed + @exposed.map {|meth| "/#{prefix}/#{meth}".squeeze('/')} + end - def register(actor, prefix) - raise ArgumentError, "#{actor.inspect} is not a Nanite::Actor subclass instance" unless Nanite::Actor === actor - log.info("Registering #{actor.inspect} with prefix #{prefix.inspect}") - prefix ||= actor.class.default_prefix - actors[prefix.to_s] = actor - end + def on_exception(proc = nil, &blk) + raise 'No callback provided for on_exception' unless proc || blk + if Nanite::Actor == self + raise 'Method name callbacks cannot be used on the Nanite::Actor superclass' if Symbol === proc || String === proc + @superclass_exception_callback = proc || blk + else + @instance_exception_callback = proc || blk + end + end - def services - actors.map {|prefix, actor| actor.class.provides_for(prefix) }.flatten.uniq - end + def superclass_exception_callback + @superclass_exception_callback + end - def actor_for(prefix) - actor = actors[prefix] - end - end -end \ No newline at end of file + def instance_exception_callback + @instance_exception_callback + end + end # ClassMethods + + module InstanceMethods + end # InstanceMethods + + end # Actor +end # Nanite \ No newline at end of file lib/nanite/actor.rb @@ -1,19 +1,24 @@ require File.dirname(__FILE__) + '/spec_helper' require 'nanite' -class WebDocumentImporter < Nanite::Actor +class WebDocumentImporter + include Nanite::Actor expose :import, :cancel - + def import 1 end def cancel 0 end + def continue + 1 + end end module Actors - class ComedyActor < Nanite::Actor + class ComedyActor + include Nanite::Actor expose :fun_tricks def fun_tricks :rabbit_in_the_hat @@ -22,14 +27,21 @@ module Actors end describe Nanite::Actor do + + describe ".expose" do + it "should single expose method only once" do + 3.times { WebDocumentImporter.expose(:continue) } + WebDocumentImporter.provides_for("webfiles").should == ["/webfiles/import", "/webfiles/cancel", "/webfiles/continue"] + end + end + describe ".default_prefix" do it "is calculated as default prefix as const path of class name" do - Nanite::Actor.default_prefix.should == "nanite/actor" Actors::ComedyActor.default_prefix.should == "actors/comedy_actor" WebDocumentImporter.default_prefix.should == "web_document_importer" - end + end end - + describe ".provides_for(prefix)" do before :each do @provides = Actors::ComedyActor.provides_for("money") @@ -46,32 +58,3 @@ describe Nanite::Actor do end end end - -describe Nanite::ActorRegistry do - before(:each) do - log = mock('log', :info => nil) - @registry = Nanite::ActorRegistry.new(log) - end - - it "should know about all services" do - @registry.register(WebDocumentImporter.new, nil) - @registry.register(Actors::ComedyActor.new, nil) - @registry.services.should == ["/actors/comedy_actor/fun_tricks", "/web_document_importer/import", "/web_document_importer/cancel"] - end - - it "should not register anything except Nanite::Actor" do - lambda{@registry.register(String.new, nil)}.should raise_error(ArgumentError) - end - - it "should register an actor" do - importer = WebDocumentImporter.new - @registry.register(importer, nil) - @registry.actors['web_document_importer'].should == importer - end - - it "should handle actors registered with a custom prefix" do - importer = WebDocumentImporter.new - @registry.register(importer, 'monkey') - @registry.actors['monkey'].should == importer - end -end \ No newline at end of file spec/actor_spec.rb @@ -1,8 +1,8 @@ require File.dirname(__FILE__) + '/spec_helper' require 'nanite' -class Foo < Nanite::Actor - +class Foo + include Nanite::Actor expose :bar, :index, :i_kill_you on_exception :handle_exception @@ -22,8 +22,8 @@ class Foo < Nanite::Actor end end -class Bar < Nanite::Actor - +class Bar + include Nanite::Actor expose :i_kill_you on_exception do |method, deliverable, error| @scope = self @@ -37,7 +37,8 @@ end # No specs, simply ensures multiple methods for assigning on_exception callback, # on_exception raises exception when called with an invalid argument. -class Doomed < Nanite::Actor +class Doomed + include Nanite::Actor on_exception do end on_exception lambda {} @@ -77,14 +78,6 @@ describe "Nanite::Dispatcher" do @dispatcher.dispatch(req) end - it "should call the on_exception callback defined on the superclass" do - callback = lambda {|actor, method, deliverable, error|} - Nanite::Actor.on_exception callback - req = Nanite::Request.new('/foo/i_kill_you', nil) - callback.should_receive(:call).with(@actor, :i_kill_you, req, duck_type(:exception, :backtrace)) - @dispatcher.dispatch(req) - end - it "should call on_exception Procs defined in a subclass with the correct arguments" do actor = Bar.new @registry.register(actor, nil) spec/dispatcher_spec.rb c6eb18b77a0a053e5879136cd2dfd16e2ffdac89 ck ckatgithub@gmail.com http://github.com/ezmobius/nanite/commit/791197244f5f1ae1f915ba49b69269a89756add5 791197244f5f1ae1f915ba49b69269a89756add5 2009-02-19T19:32:22-08:00 2009-02-19T19:32:22-08:00 Refactored Nanite::Actor. Made following changes around Nanite:Actor: - Made Actor a module to be included in any class. - Allow same method to be included in @exposed list only once. - Created own file for ActorRegistry. - Updated specs to reflect refactoring. - Updated examples to reflect refactoring. 2eaa6a80fdab01363acfc33ebcf06dd04f0e71af ck ckatgithub@gmail.com