zactor 0.0.4

data/lib/zactor/broker.rb

@@ -0,0 +1,71 @@
+module Zactor
+  class BrokerIn
+    attr_accessor :broker, :params 
+    def initialize(broker, params = {})
+      @broker = broker
+      @params = params
+      init_connection
+    end
+    
+    def on_readable(socket, messages)
+      Zactor.logger.debug "Broker: messages"
+      @broker.pub.request messages
+    end
+    
+    def close
+       @connection.unbind
+    rescue
+    end
+  end
+  
+  class BrokerPub
+    include ZMQMEssages
+    def initialize(broker)
+      @broker = broker
+      @connection = Zactor.zmq.bind ZMQ::PUB, "inproc://zactor_broker_pub", self
+      @socket = @connection.socket
+    end
+    
+    def request(messages)
+      Zactor.logger.debug { "Broker: request #{messages.map(&:copy_out_string).inspect}" }
+      send_messages messages
+    end
+    
+    def close
+       @connection.unbind
+    rescue
+    end
+  end
+  
+  class BrokerSub < BrokerIn
+    def init_connection
+      Zactor.logger.info "Starting sub broker tcp://0.0.0.0:#{Zactor.broker_port}"
+      @connection = Zactor.zmq.bind ZMQ::SUB, "tcp://0.0.0.0:#{Zactor.broker_port}", self
+      @connection.bind "inproc://zactor_broker_sub"
+      @connection.subscribe ''
+    end
+  end
+  
+  class BrokerPull < BrokerIn
+    def init_connection
+      Zactor.logger.info "Starting pull broker tcp://#{params[:host]}"
+      @connection = Zactor.zmq.connect ZMQ::PULL, "tcp://#{params[:host]}", self
+    end
+  end
+  
+  class Broker
+    attr_accessor :sub, :pub
+    def initialize(params = {})
+      Zactor.logger.info "Broker: starting"
+      @pub = BrokerPub.new self
+      @subs = []
+      @subs << BrokerSub.new(self)
+      @subs << BrokerPull.new(self, :host => params[:balancer]) if params[:balancer]
+    end
+    
+    def finish
+      @pub.close
+      @subs.each(&:close)
+    end
+  end
+end

data/lib/zactor/log_subscriber.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+require 'active_support/log_subscriber'
+module Zactor
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def logger
+      Zactor.logger
+    end
+
+    def merge(event)
+      payload   = event.payload
+
+      message = "[Zactor](%.0fms) sending request '#{payload[:event]}' to '#{payload[:actor]}'' with params #{paylaod[:args].inspect}" % event.duration
+      debug message
+    end
+
+    def send_to(event)
+      payload   = event.payload
+
+      message = "[Zactor] sending messages to '#{payload[:actor]}'" % event.duration
+      debug message
+    end
+  end
+end
+
+Zactor::LogSubscriber.attach_to :zactor

data/lib/zactor/message.rb

@@ -0,0 +1,23 @@
+module Zactor
+  class Message
+    attr_accessor :actor, :params
+    attr_accessor :callback_id, :args
+    def initialize(actor, params = {})
+      @actor = actor
+      @params = params
+    end
+    
+    def sender
+      params[:sender]
+    end
+    
+    def args
+      params[:args]
+    end
+    
+    def reply(*args)
+      return false unless params[:callback_id]
+      actor.send_reply sender, params[:callback_id], *args
+    end
+  end
+end

data/lib/zactor/version.rb

@@ -0,0 +1,3 @@
+module Zactor
+  VERSION = "0.0.4"
+end

data/lib/zactor.rb

@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+require 'ruby_interface'
+require 'active_support/all'
+require 'ffi-rzmq'
+require 'em-zeromq'
+require 'bson'
+
+module Zactor
+  extend ActiveSupport::Autoload
+
+  autoload :Broker
+  autoload :ActorSub
+  autoload :ActorPub
+  autoload :Message
+  require 'zactor/log_subscriber'
+
+  mattr_accessor :stub
+  mattr_accessor :zmq, :logger
+  
+  class << self    
+    def broker
+      @broker
+    end
+    
+    def broker_port
+      @broker_port
+    end
+    
+    def host
+      @host
+    end
+    
+    def start(broker_port, params = {})
+      self.zmq ||= EM::ZeroMQ::Context.new(1)
+      self.logger ||= Logger.new(STDOUT).tap { |o| o.level = params[:debug] ? Logger::DEBUG : Logger::INFO }
+      @host = "#{params.delete(:host) || '0.0.0.0'}:#{broker_port}"
+      @broker_port = broker_port
+      @params = params
+      
+      logger.info "Starting Zactor"
+      @broker = Broker.new :balancer => params[:balancer]
+    end
+    
+    def get_actor(pid, options = {})
+      h = options[:host] || host
+      { 'identity' => pid, 'host' => h }
+    end
+    
+    def register(zactor)
+      @zactors ||= {}
+      @zactors[zactor] = true
+    end
+    
+    def deregister(zactor)
+      @zactors.delete zactor
+    end
+    
+    def finish
+      @zactors.keys.each(&:finish)
+      @broker.finish
+    end
+    
+    def clear
+      @zactors = {}
+    end
+  end
+
+  
+  module ZMQMEssages
+    class ZMQMessage
+      attr_accessor :res
+      def initialize(&blk)
+        @res = []
+        blk.call self
+      end
+      
+      def str(str)
+        @res << ZMQ::Message.new.tap { |o| o.copy_in_string str.to_s }
+      end
+      
+      def mes(message)
+        @res << message
+      end
+    end
+    
+    def send_messages(messages)
+      last = messages[-1]
+      messages[0...-1].each do |mes|
+        sent = @socket.send mes, ZMQ::NOBLOCK | ZMQ::SNDMORE
+        break unless sent
+      end
+      sent = @socket.send last, ZMQ::NOBLOCK
+      unless sent
+        Zactor.logger.info "[Zactor] Error while sending messages"
+      end
+    end
+    
+    def messages(&blk)
+      ZMQMessage.new(&blk).res
+    end
+  end
+  
+  
+  extend RubyInterface
+  interface :zactor do
+    interfaced do
+      self.zactor do
+        event(:finish) { |o| o.finish }
+        event(:link) do |o, msg| 
+          o.zactor.linked msg
+          # msg.reply :ok
+        end
+        event(:link_ping) do |o, msg|
+          msg.reply :pong
+        end
+      end
+    end
+    
+    include ZMQMEssages
+    
+    class_attribute :identity_val
+    class_attribute :events
+    self.events = {}
+    class << self
+      def identity(val)
+        self.identity_val = val
+      end
+      
+      def event(name, &clb)
+        self.events = self.events.merge name.to_sym => clb
+      end
+    end
+    attr_accessor :actor, :identity
+    attr_accessor :pubs
+    
+    # Инициализация, подписывается на сообщения для себя, создает сокет для отправки локальных сообщений
+    def init
+      @actor = Zactor.get_actor @identity || self.class.identity_val || "actor.#{owner.object_id}-#{Zactor.host}"
+      Zactor.register self
+      return if Zactor.stub
+      @sub = make_sub
+      @callbacks, @timeouts = {}, {}
+      @pubs = {}
+      @pubs["0.0.0.0:#{Zactor.broker_port}"] = make_pub "inproc://zactor_broker_sub"
+    end
+    
+    # Закрываем все соедниения и чистим сисьему. Обязательно нужно делать, когда объект перестает существовать
+    def finish
+      Zactor.deregister self
+      return if Zactor.stub
+      if @linked
+        @linked.each do |link|
+          link.reply :finish
+        end
+      end
+      @finished = true
+      @sub.close
+      @pubs.values.each(&:close)
+    end
+    
+    def make_pub(endpoint)
+      Zactor::ActorPub.new self, endpoint
+    end
+    
+    def make_sub
+      Zactor::ActorSub.new self
+    end
+    
+    def send_request(actor, event, *args, &clb)
+      return if @finished || Zactor.stub
+      @callbacks[clb.object_id.to_s] = clb if clb
+      send_to actor, messages { |m|
+        m.str 'request'
+        m.str "#{clb ? clb.object_id : ''}"
+        m.str event
+        m.str BSON.serialize({ 'args' => args })
+      }
+      @last_callback = clb.object_id.to_s
+      self
+    end
+    
+    def timeout(secs, &clb)
+      raise "Only for requests" unless @last_callback
+      @timeouts[@last_callback] = EM.add_timer(secs, &clb)
+    end
+    
+    def send_reply(actor, callback_id, *args)
+      return if @finished || Zactor.stub
+      Zactor.logger.debug "Zactor: send reply"
+      send_to actor, messages { |m|
+        m.str 'reply'
+        m.str callback_id
+        m.str BSON.serialize({ 'args' => args })
+      }
+    end
+    
+    def send_to(actor, mes = [])
+      pub = @pubs[actor['host']] ||= make_pub("tcp://#{actor['host']}")
+      pub.send_messages(messages { |m|
+        m.str actor['identity']
+        m.str bson_actor
+      } + mes)
+    end
+    
+    def link(actor, &clb)
+      Zactor.logger.debug { "Zactor: link #{actor} with #{self.actor}"}
+      send_request actor, :link do
+        clb.call
+      end
+      link_ping actor, &clb
+      self
+    end
+    
+    def link_ping(actor, &clb)
+      EM.add_timer(5) do
+        unless @finished
+          send_request(actor, :link_ping) do
+            link_ping actor, &clb
+          end.timeout(5) do
+            clb.call
+          end
+        end
+      end
+    end
+    
+    def linked(msg)
+      Zactor.logger.debug { "Zactor: linked #{actor} with #{msg.sender}"}
+      @linked ||= []
+      @linked << msg
+    end
+    
+    def receive_reply(callback_id, *args)
+      Zactor.logger.debug "Zactor: receive reply"
+      if (callback = @callbacks[callback_id])
+        if timeout = @timeouts[callback_id]
+          EM.cancel_timer timeout
+        end
+        callback.call(*args)
+      end
+    end
+    
+    def receive_request(sender, event_name, callback_id, *args)
+      Zactor.logger.debug "Zactor: receive request"
+      mes = Message.new self, :sender => sender, :callback_id => callback_id, :args => args
+      if (event = self.class.events[event_name.to_sym])
+         event.call owner, mes, *args
+       else
+         raise "Undefined event #{event_name}"
+       end
+    end
+    
+    def bson_actor
+      @bson_actor ||= BSON.serialize(@actor).to_s
+    end
+
+    
+    def inspect
+      "<#Zactor Interface for #{owner.inspect}"
+    end
+
+  end
+  
+end

data/spec/lib/actor_spec.rb

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Zactor actor" do
+  class A
+    include Zactor
+  end
+  before do
+    stub(Zactor::Broker).new
+    Zactor.start 8000
+  end
+  describe "init" do
+    let(:actor) { A.new.zactor }
+    let(:sub) { Object.new }
+    let(:local_pub) { Object.new }
+    before do
+      stub(actor).make_sub { sub }
+      stub(actor).make_pub { local_pub }
+    end
+    it "должен зарегистрировать себя" do
+      mock(Zactor).register actor
+      actor.init
+    end
+    
+    it "должен создать sub сокет" do
+      mock(actor).make_sub { sub }
+      actor.init
+      actor.instance_eval { @sub }.should eq(sub)
+    end
+    
+    it "должен создать pub сокет для локальных вызовов" do
+      mock(actor).make_pub("inproc://zactor_broker_sub") { local_pub }      
+      actor.init      
+      actor.instance_eval { @pubs['0.0.0.0:8000'] }.should eq(local_pub)
+    end
+    
+    describe "identity" do
+      it "по-умолчанию" do
+        actor.init
+        actor.actor.should eq({ 'identity' => "actor.#{actor.owner.object_id}-0.0.0.0:8000", 'host' => '0.0.0.0:8000' })
+      end
+      
+      it "с глобальным указанием" do
+        A.zactor.identity "a"
+        actor.init
+        actor.actor.should eq({ 'identity' => "a", 'host' => '0.0.0.0:8000' })
+      end
+      
+      it "с указанием для этого объекта" do
+        actor.identity = "b"
+        actor.init
+        actor.actor.should eq({ 'identity' => "b", 'host' => '0.0.0.0:8000' })
+      end
+    end
+    
+    describe "after init" do
+      include Zactor::ZMQMEssages
+      
+      def assert_messages(got, expected)
+        got.map(&:copy_out_string).should eq(expected.map(&:copy_out_string))
+      end
+      
+      before do
+        actor.init
+      end
+      describe "send_to" do
+        it "должен отправить в локальный pub для локального объекта" do
+          mes = messages { |m|  }
+          stub(local_pub).send_messages do |mes|
+            assert_messages mes, messages { |m|
+              m.str('b')
+              m.str(actor.bson_actor)
+            }
+          end
+          actor.send_to Zactor.get_actor('b')
+        end
+        
+        it "должен отправить в удаленный pub для удаленного объекта, перед этим создав его" do
+          remote_pub = Object.new
+          mock(actor).make_pub("tcp://192.168.1.1:3000") { remote_pub }
+          stub(remote_pub).send_messages do |mes|
+            assert_messages mes, messages { |m| m.str('b'); m.str(actor.bson_actor) }
+          end
+          actor.send_to Zactor.get_actor('b', :host => '192.168.1.1:3000')
+        end
+      end
+
+      describe "send_request" do
+        it "должен отправлять сообщение типа request" do
+          stub(local_pub).send_messages do |mes|
+            assert_messages mes, messages { |m| 
+              m.str('b')
+              m.str(actor.bson_actor)
+
+              m.str 'request'
+              m.str ""
+              m.str "show"
+              m.str BSON.serialize({ 'args' => ['foo', :bar] })
+            }
+          end
+          actor.send_request Zactor.get_actor('b'), :show, 'foo', :bar
+        end
+      end
+
+      describe "send_reply" do
+        it "должен отправлять сообщение типа reply" do
+          stub(local_pub).send_messages do |mes|
+            assert_messages mes, messages { |m| 
+              m.str('b')
+              m.str(actor.bson_actor)
+
+              m.str 'reply'
+              m.str 5
+              m.str BSON.serialize({ 'args' => ['foo', :bar] })
+            }
+          end
+          actor.send_reply Zactor.get_actor('b'), 5, 'foo', :bar
+        end
+      end
+
+      describe "receive_reply" do
+
+      end
+
+      describe "receive_request" do
+
+      end
+
+      describe "finish" do
+
+      end
+    end    
+
+  end
+end

data/spec/lib/exchange_spec.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+require 'spec_helper'
+require "em-spec/rspec"
+
+describe "Zactor" do
+  include EM::SpecHelper
+  module Exchange
+    class A
+      include Zactor
+
+      def initialize
+        zactor.init
+      end
+
+      def ping(actor = Zactor.get_actor("b")) 
+        zactor.send_request actor, :ping do |res|
+          reply
+        end
+      end
+      
+      def reply
+        
+      end
+    end
+
+    class B
+      include Zactor
+
+      zactor do
+        identity "b"
+
+        event(:ping) do |o, msg|
+          o.receive
+          msg.reply "Pong!"
+        end
+      end
+
+      def initialize
+        zactor.init
+      end
+
+      def receive
+        
+      end
+    end
+  end
+  
+  after do
+    Zactor.clear
+    Zactor.finish
+  end
+  
+  it "B должен получить сообщение" do
+    em do
+      Zactor.start 8000, :debug => true
+      Exchange::A.new.ping
+      b = Exchange::B.new
+      mock.proxy(b).receive { done }
+    end
+  end
+  
+  it "A должен получить ответ" do
+    em do
+      Zactor.start 8000, :debug => true
+      a = Exchange::A.new
+      a.ping
+      Exchange::B.new
+      mock.proxy(a).reply { done }
+    end
+  end
+  
+  it "Если задан таймаут, то он должен срабатывать" do
+    em(7) do
+      Zactor.start 8000, :debug => true
+      a = Exchange::A.new.ping.timeout(5) do
+        done
+      end
+    end
+  end
+end

data/spec/lib/link_spec.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+require 'spec_helper'
+require "em-spec/rspec"
+
+describe "Zactor" do
+  include EM::SpecHelper
+  module Link
+    class A
+      include Zactor
+
+      def initialize
+        zactor.init
+      end
+    end
+
+    class B
+      include Zactor
+
+      def initialize
+        zactor.init
+      end
+    end
+  end
+  
+  after do
+    puts "FINISH ZACTOR"
+    Zactor.finish
+  end
+  
+  it "A должен уведомляться о смерти B" do
+    em do
+      Zactor.start 8000, :debug => true
+      a = Link::A.new
+      b = Link::B.new
+      a.zactor.link b.zactor.actor do
+        done
+      end
+      EM.add_timer(0.5) do
+        b.zactor.finish
+      end
+    end
+  end
+  
+  # it "A должен уведомляться о смерти B в случае удаления объекта гарбэйдж коллектором" do
+  #   
+  # end
+  
+  it "A должен уведомляться о смерти B, даже если B закончил выполнение неожиданно" do    
+    em(12) do
+      EM.add_timer(0.5) do #FIXME ZMQ-сокетам нужно время чтобы закрыться. Нужно придумать, что с этим делать
+        Zactor.start 8000, :debug => true
+        a = Link::A.new
+        b = Link::B.new
+        a.zactor.link b.zactor.actor do
+          done
+        end
+        EM.add_timer(0.5) do
+          b.zactor.instance_eval do
+            @linked = []
+          end
+          b.zactor.finish
+        end
+      end
+    end
+  end
+end

data/spec/lib/zactor_spec.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Zactor" do
+  describe "start" do
+    before do
+      stub(Zactor::Broker).new
+    end
+    it "должен выставлять хост по-умолчанию 0.0.0.0" do
+      Zactor.start 8000
+      Zactor.host.should eq('0.0.0.0:8000')
+    end
+    
+    it "должен выставлять хост с учетом переданного" do
+      Zactor.start 8000, :host => '192.168.1.1'
+      Zactor.host.should eq('192.168.1.1:8000')
+    end
+    
+    it "должен создавать новый брокер с указаным балансером" do
+      mock(Zactor::Broker).new :balancer => '0.0.0.0:4000'
+      Zactor.start 8000, :balancer => '0.0.0.0:4000'
+    end
+  end
+  
+  describe "get_actor" do
+    before do
+      stub(Zactor::Broker).new
+      Zactor.start 8000
+    end
+    it "в качестве хоста по-умолчанию ставит себя же" do
+      Zactor.get_actor("actor1").should eq({ 'identity' => 'actor1', 'host' => '0.0.0.0:8000' })
+    end
+    
+    
+    it "в качестве хоста ставит переданный" do
+      Zactor.get_actor("actor1", :host => '192.168.1.1:3000').should eq({ 'identity' => 'actor1', 'host' => '192.168.1.1:3000' })
+    end
+  end
+end