zactor 0.0.4 → 0.0.5

data/lib/zactor.rb

@@ -1,263 +0,0 @@
-# -*- 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

@@ -1,136 +0,0 @@
-# -*- 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

@@ -1,81 +0,0 @@
-# -*- 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

@@ -1,67 +0,0 @@
-# -*- 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

@@ -1,40 +0,0 @@
-# -*- 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