zactor 0.0.5 → 0.0.6

data/examples/chat/server.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+# ruby server.rb PORT
+# ruby server.rb 8000
+require 'bundler'
+ENV['BUNDLE_GEMFILE'] = File.join(File.dirname(__FILE__), '..', '..', 'Gemfile')
+Bundler.setup(:default)
+
+require 'zactor'
+
+class Server
+  include Zactor
+  
+  zactor do
+    identity "server"
+    
+    event(:new_client) do |o, msg, login|
+      o.new_client msg.sender, login
+      msg.reply :ok
+    end
+    
+    event(:client_request) do |o, msg, login|
+      if client = o.clients.detect { |k, v| v == login }
+        msg.reply :ok, client.first
+      else
+        msg.reply :error
+      end
+    end
+    
+    event(:message) do |o, msg, text|
+      o.send_message msg.sender, text
+    end
+  end
+  
+  attr_accessor :clients
+  def initialize
+    zactor.init
+    @clients = {}
+  end
+  
+  def new_client(client, login)
+    @clients[client] = login
+    send_message client, "присоединился"
+    zactor.link client do
+      send_message client, "отсоединился"
+      clients.delete client
+    end
+  end
+  
+  def send_message(from, message)
+    (clients.keys - [from]).each { |c| zactor.send_request c, :message, "#{clients[from]}: #{message}"}
+  end
+end
+
+EM.run do
+  Zactor.start ARGV[0]#, :debug => true
+  Server.new
+  puts "Server started"
+end

data/examples/ping/inproc.rb

@@ -0,0 +1,50 @@
+require "rubygems"
+require "bundler"
+
+ENV['BUNDLE_GEMFILE'] = File.join(File.dirname(__FILE__), '..', '..', 'Gemfile')
+
+Bundler.setup(:default, :development)
+
+require 'zactor'
+require 'eventmachine'
+
+class A
+  include Zactor
+
+  def initialize
+    zactor.init
+    ping Zactor.get_actor("b")
+  end
+
+  def ping(actor) 
+    puts "Ping!"
+    zactor.send_request actor, :ping do |res|
+      puts res
+    end
+  end
+end
+
+
+class B
+  include Zactor
+
+  zactor do
+    identity "b"
+  
+    event(:ping) do |o, msg|
+      msg.reply "Pong!"
+    end
+  end
+
+  def initialize
+    zactor.init
+  end
+
+end
+
+EM.run do
+  Zactor.start 8000
+
+  a = A.new
+  b = B.new
+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/lib/zactor/actor_pub.rb

@@ -0,0 +1,19 @@
+module Zactor
+  class ActorPub
+    include ZMQMEssages
+    
+    attr_accessor :actor
+    def initialize(actor, endpoint)
+      Zactor.logger.debug "ZactorPub (#{actor.actor}): starting"
+      @actor = actor
+      @connection = Zactor.zmq.connect ZMQ::PUB, endpoint, self
+      @socket = @connection.socket
+    end
+    
+    def close
+      @connection.unbind
+    rescue
+    end
+  end
+ 
+end

data/lib/zactor/actor_sub.rb

@@ -0,0 +1,46 @@
+module Zactor
+  class ActorSub
+    attr_accessor :actor
+    def initialize(actor)
+      Zactor.logger.debug "ZactorSub (#{actor.actor}): starting"
+      @actor = actor
+      @connection = Zactor.zmq.connect ZMQ::SUB, "inproc://zactor_broker_pub", self
+      @connection.subscribe actor.actor['identity']
+    end
+    
+    def on_readable(socket, messages)
+      @connection.notify_readable = true
+      Zactor.logger.debug "ZactorSub for #{actor.actor}: Messages!"
+      to = messages.shift
+      sender = messages.shift
+      case messages.shift.copy_out_string
+      when "reply"
+        reply messages
+      when "request"
+        request sender, messages
+      end      
+    end
+    
+    def request(sender_mes, messages)
+      Zactor.logger.debug "ZactorSub for #{actor.actor}: request!"
+      sender = BSON.deserialize(sender_mes.copy_out_string)
+      callback_id = messages[0].copy_out_string
+      event = messages[1].copy_out_string
+      args = BSON.deserialize(messages[2].copy_out_string)['args']      
+      actor.receive_request sender, event, callback_id, *args
+    end
+    
+    def reply(messages)
+      Zactor.logger.debug "ZactorSub for #{actor.actor}: reply!"
+      callback_id = messages[0].copy_out_string
+      if callback_id != ''
+        actor.receive_reply callback_id, *BSON.deserialize(messages[1].copy_out_string)['args']
+      end
+    end
+    
+    def close
+       @connection.unbind
+    rescue
+    end
+  end 
+end

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