foreign_actor 0.0.1

data/example/Procfile

@@ -0,0 +1,2 @@
+master: ruby ../bin/device
+worker: ruby worker.rb

data/example/client.rb

@@ -0,0 +1,27 @@
+require_relative 'common'
+
+class ClientGroup < Celluloid::SupervisionGroup
+  supervise ForeignActor::Reactor, :as => :xs_reactor
+  
+end
+
+ClientGroup.run!
+
+# cl = ForeignActor::Client.create(CLIENT_ENDPOINT)
+cl = ForeignActor::Client.new(CLIENT_ENDPOINT)
+
+cl.async.do_it(0)
+
+loop do
+  f = []
+  
+  p cl.do_it(2)
+  
+  started_at = Time.now
+  4.times {|n| f << cl.future.do_it(n) }
+
+  p f.map(&:value)
+
+  elapsed = (Time.now - started_at)
+  puts "time: #{elapsed} seconds"
+end

data/example/common.rb

@@ -0,0 +1,10 @@
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'foreign_actor'
+
+$stdout.sync = true
+
+CLIENT_ENDPOINT = 'tcp://127.0.0.1:7000'
+WORKERS_ENDPOINT = 'tcp://127.0.0.1:7001'

data/example/device.yml

@@ -0,0 +1,7 @@
+endpoint1:
+  front: 'tcp://*:7000'
+  back: 'tcp://*:7001'
+
+endpoint2:
+  front: 'tcp://*:7002'
+  back: 'tcp://*:7003'

data/example/worker.rb

@@ -0,0 +1,42 @@
+require_relative 'common'
+
+class Worker
+  include Celluloid
+  
+  def initialize(endpoint)
+    Actor[:xs_reactor].serve_actor!(endpoint, Actor.current)
+  end
+  
+  def do_it(n)
+    # if n == 2
+    #   raise "what ?"
+    # end
+    
+    Kernel.sleep 1
+    
+    # if n == 0
+    #   puts "did it !"
+    # end
+    
+    "toto #{$$}"
+  end
+  
+end
+
+class RootGroup < Celluloid::SupervisionGroup
+  supervise ForeignActor::Reactor, :as => :xs_reactor
+  # supervise ForeignActor::WorkersSupervisor
+  supervise Worker, :as => :worker1, args: [WORKERS_ENDPOINT]
+  
+end
+
+RootGroup.run!
+
+# Celluloid::Actor[:workers].register_server(:worker1, Worker, WORKERS_ENDPOINT)
+
+# Celluloid::Actor[:xs_reactor].serve_actor(WORKERS_ENDPOINT, Worker.new)
+
+puts "Worker started."
+
+trap("INT") { Celluloid.shutdown; exit }
+sleep

data/example2/Procfile

@@ -0,0 +1,2 @@
+master: ruby ../bin/device
+node: ruby node.rb

data/example2/README.md

@@ -0,0 +1,9 @@
+
+In this example each node is both a client and a server, the more nodes you start,
+the quicker their tasks will complete. If a node is killed the job will timeout.
+
+Just run:
+$ ruby ../bin/device
+
+And then in multiple consoles:
+$ ruby node.rb

data/example2/device.yml

@@ -0,0 +1,4 @@
+endpoint1:
+  front: 'tcp://*:7000'
+  back: 'tcp://*:7001'
+

data/example2/node.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'foreign_actor'
+
+$stdout.sync = true
+
+CLIENT_ENDPOINT = 'tcp://127.0.0.1:7000'
+WORKERS_ENDPOINT = 'tcp://127.0.0.1:7001'
+
+node_id = ARGV[0] || "node#{rand(100)}"
+
+class Worker
+  include Celluloid
+  
+  def initialize(endpoint)
+    Actor[:xs_reactor].serve_actor!(endpoint, Actor.current)
+  end
+  
+  def handle_it(token)
+    puts "Got #{token}"
+    Kernel.sleep(rand(2000).to_f / 1000)
+    "#{$$} : #{token}"
+  end
+  
+end
+
+
+
+class RootGroup < Celluloid::SupervisionGroup
+  supervise ForeignActor::Reactor, :as => :xs_reactor
+  supervise Worker, :as => :worker1, args: [WORKERS_ENDPOINT]
+
+end
+
+RootGroup.run!
+
+puts "Node #{node_id} started."
+trap("INT") { Celluloid.shutdown; exit }
+
+cl = ForeignActor::Client.new(CLIENT_ENDPOINT, 4)
+
+task_id = 0
+
+loop do
+  f = []
+  
+  started_at = Time.now
+  4.times do |n|
+    task_id += 1
+    f << cl.future(:handle_it, "#{node_id}:#{task_id}")
+  end
+
+  p f.map(&:value)
+
+  elapsed = (Time.now - started_at)
+  puts "time: #{elapsed} seconds"
+end
+

data/foreign_actor.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/foreign_actor/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Julien Ammous"]
+  gem.email         = ["schmurfy@gmail.com"]
+  gem.description   = %q{Distributed Actors above Celluloid}
+  gem.summary       = %q{Distributed Actors}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = ['device']
+  gem.name          = "foreign_actor"
+  gem.require_paths = ["lib"]
+  gem.version       = ForeignWorker::VERSION
+  
+  gem.add_dependency 'ffi-rxs',   '~> 1.2.1'
+  gem.add_dependency 'celluloid', '= 0.12.3'
+  gem.add_dependency 'msgpack',   '= 0.4.7'
+end

data/lib/foreign_actor/client.rb

@@ -0,0 +1,90 @@
+require 'celluloid'
+
+module ForeignActor
+  
+  State = Struct.new(:state) do
+    attr_accessor :state
+  end
+  
+  class ClientProxy < Celluloid::ActorProxy
+    class MethodMissingRedirector
+      def initialize(&block)
+        @block = block
+      end
+      
+      def method_missing(*args)
+        @block.call(*args)
+      end
+    end
+    
+    def future(meth = nil, *args)
+      if meth
+        do_call(:future, meth, args)
+      else
+        MethodMissingRedirector.new do |method, *args|
+          do_call(:future, method, args)
+        end
+      end
+    end
+    
+    def async(meth = nil, *args)
+      if meth
+        do_call(:async, meth, args)
+      else
+        MethodMissingRedirector.new do |method, *args|
+          do_call(:async, method, args)
+        end
+      end
+    end
+        
+    def method_missing(meth, *args, &block)
+      # bang methods are async calls
+      type = :sync
+      if meth.match(/!$/)
+        meth = meth.to_s
+        meth.slice!(-1, 1)
+        type = :async
+      end
+      
+      do_call(type, meth, args)
+    end
+  
+  private
+    def do_call(type, meth, args)
+      case type
+      when :async   then Celluloid::Actor.async(@mailbox, :async_remote_request, meth, *args)
+      when :sync    then Celluloid::Actor.call(@mailbox, :sync_remote_request, meth, *args)
+      when :future  then Celluloid::Actor.future(@mailbox, :sync_remote_request, meth, *args)
+      end
+    end
+  
+  end
+  
+  class Client
+    include Celluloid
+    
+    proxy_class ClientProxy
+    
+    def initialize(endpoint, request_timeout = nil, reactor_name = :xs_reactor)
+      @reactor_name = reactor_name
+      @request_timeout = request_timeout
+      @socket = Actor[@reactor_name].socket(XS::XREQ)
+      rc = @socket.connect(endpoint)
+      unless XS::Util.resultcode_ok?(rc)
+        raise IOError, "connect failed: #{XS::Util.error_string}"
+      end
+
+    end
+    
+    def sync_remote_request(method, *args)
+      Actor[@reactor_name].request(@socket, true, @request_timeout, method, *args)
+    end
+    
+    
+    def async_remote_request(method, *args)
+      Actor[@reactor_name].request(@socket, false, @request_timeout, method, *args)
+    end
+            
+  end
+  
+end

data/lib/foreign_actor/reactor.rb

@@ -0,0 +1,275 @@
+require 'msgpack'
+require 'celluloid'
+require 'timers'
+
+module ForeignActor
+    
+  class InternalReactor
+    
+    StopLoop = Class.new(RuntimeError)
+    
+    def initialize(context = nil, poller = nil, timers = nil)
+      @context = context || XS::Context.new
+      @poller = poller || XS::Poller.new
+      @waiting_readables = {}
+      @servers = {}
+      @timers = timers || Timers.new
+      
+      @control_socket_srv = @context.socket(XS::PAIR)
+      @control_socket_cl = @context.socket(XS::PAIR)
+      @control_messages = Array.new
+      
+      addr = "inproc://ctrl"
+      @control_socket_srv.bind(addr)
+      @control_socket_cl.connect(addr)
+      
+      @poller.register_readable(@control_socket_srv)
+      
+      async(:run)
+    end
+
+    
+    def suspend_reactor(msg = 'suspend')
+      if @control_socket_cl
+        @control_messages << msg
+        @control_socket_cl.send_string('')
+      end
+    end
+    
+    def wakeup_reactor()
+      signal(:resume_reactor)
+    end
+    
+        
+    def socket(*args)
+      @context.socket(*args)
+    end
+    
+    
+    def request(s, sync, timeout, method, *args)
+      type = sync ? 'sync_call' : 'async_call'
+      msg = build_msg(Celluloid::Task.current.object_id, type, method, args)
+      
+      send_msg(s, '', msg)
+      wait_answer(s, timeout) if sync
+    end
+    
+    # wait until the socket receives a new message
+    def wait_answer(s, timeout = nil)
+      task = Celluloid::Task.current
+      task_id = task.object_id
+      
+      if @waiting_readables.has_key?(task_id)
+        raise ArgumentError, "task is already listening ???"
+      end
+      
+      @poller.register_readable(s)
+      @waiting_readables[s] ||= {}
+      @waiting_readables[s][task_id] = task
+      
+      timer = nil
+      if timeout
+        timer = @timers.after(timeout){ task.resume(:timeout) }
+      end
+      
+      Celluloid::Task.suspend(:xs_wait).tap do
+        timer.cancel() if timer
+      end
+    end
+    
+    def serve_actor(endpoint, actor_or_name)
+      s = socket(XS::XREP)
+      rc = s.connect(endpoint)
+      unless XS::Util.resultcode_ok?(rc)
+        raise IOError, "connect failed: #{XS::Util.error_string}"
+      end
+      
+      if @servers.has_key?(s)
+        raise ArgumentError, "another class is already registered as server for #{s}"
+      end
+      
+      register_server(s, actor_or_name)
+      @poller.register_readable(s)
+    end
+        
+    def run
+      loop { run_once() }
+    rescue StopLoop
+      
+    end
+        
+    def run_once(allow_blocking = true)
+      @timers.fire()
+      
+      wait_time = if @timers.wait_interval
+        @timers.wait_interval * 1000
+      else
+        allow_blocking ? :blocking : 0
+      end
+      
+      rc = @poller.poll(wait_time)
+      unless XS::Util.resultcode_ok?(rc)
+        raise IOError, "libxs poll error: #{XS::Util.error_string}"
+      end
+      
+      @poller.readables.each do |s|
+        parts = receive_msg(s)
+        handle_message(s, parts)
+      end
+      
+      rc
+    end
+    
+  private
+    def build_response(src_msg, ret)
+      Serializer.pack(
+          task_id:  src_msg['task_id'],
+          type:     'response',
+          ret:      ret
+        )
+    end
+    
+    def build_msg(task_id, type, method, args)
+      Serializer.pack(
+          task_id:    task_id,
+          type:       type,
+          method:     method,
+          arguments:  args
+        )
+    end
+    
+    def register_server(s, actor_or_name)
+      @servers[s] = actor_or_name
+    end
+
+    
+    def control_socket?(s)
+      s == @control_socket_srv
+    end
+    
+    def handle_message(s, parts)
+      # control messages
+      if control_socket?(s)
+        ctrl_msg = @control_messages.shift
+        if ctrl_msg == 'exit'
+          puts "Exiting..."
+          signal(:exit_confirmed)
+          raise StopLoop
+          
+        elsif ctrl_msg == 'suspend'
+          # allow the celluloid reactor to
+          # process its own waiting messages
+          wait(:resume_reactor)
+          
+          # clear any suspend messages waiting to
+          # preventing sspending te reactor when nothing
+          # is actually expecting to (and as a result nothing
+          # will ever resume it).
+          @control_messages.reject!{|m| m == 'suspend' }
+        end
+        
+      else
+        # or regular messages
+        
+        # split the routing ids from the message
+        separator_index = parts.index('')
+        p parts unless separator_index
+        routing_ids = parts.slice!(0..separator_index)
+        
+        msg = MessagePack.unpack(parts[0])
+        
+        type = msg.delete('type')
+        case type
+        when 'sync_call'
+          # call it locally and then send the result back
+          handle_call(s, msg, routing_ids: routing_ids)
+                      
+        when 'async_call'
+          handle_call(s, msg)
+          
+        when 'response'
+          if @waiting_readables[s]
+            task_id = msg['task_id']
+            task = @waiting_readables[s].delete(task_id)
+            if task && task.running?
+              task.resume(msg['ret'])
+            end
+          end
+        
+        else
+          puts "unknown type: #{type}"
+          
+        end
+      end
+    end
+    
+    
+    def handle_call(socket, msg, opts = {})
+      routing_ids = opts.delete(:routing_ids)
+      raise "unknown options: #{opts}" unless opts.empty?
+      
+      server = @servers[socket]
+      unless server
+        raise ArgumentError, "no server registered for #{socket}"
+      end
+      
+      if server.is_a?(Symbol)
+        server = Actor[server]
+      end
+      
+      method, args = msg.values_at('method', 'arguments')
+      
+      unless server
+        raise ArgumentError, "no server found for #{method}(#{args.join(', ')})"
+      end
+      
+      # if we have the source id send the response, otherwise
+      # discards it.
+      if routing_ids
+        ret = server.send(method, *args)
+        msg = build_response(msg, ret)
+        send_msg(socket, *routing_ids, msg)
+      else
+        server.async(method, *args)
+      end
+    end
+    
+    def receive_msg(s)
+      parts = []
+      loop do
+        data = ""
+        if s.recv_string(data, XS::DONTWAIT) == -1
+          raise "error while reading socket: #{}"
+        end
+        parts << data
+        break unless s.more_parts?
+      end
+      
+      parts
+    end
+    
+    def send_msg(s, *parts)
+      parts[0...-1].each do |m|
+        handle_xs_err(s, :send_string, m, XS::DONTWAIT | XS::SNDMORE)
+      end
+      
+      handle_xs_err(s, :send_string, parts[-1], XS::DONTWAIT)
+    end
+    
+    def handle_xs_err(s, method, *args)
+      rc = s.send(method, *args)
+      unless XS::Util.resultcode_ok?(rc)
+        raise "error: #{method}: #{XS::Util.error_string}"
+      end
+    end
+    
+  end
+  
+  class Reactor < InternalReactor
+    include Celluloid
+    mailbox_class ReactorMailbox
+    
+  end
+
+  
+end