pomelo-citrus-rpc 0.0.2

data/lib/citrus-rpc/util/utils.rb

@@ -0,0 +1,42 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+module CitrusRpc
+  # Utils
+  #
+  #
+  module Utils
+    # EventEmitter
+    #
+    #
+    module EventEmitter
+      # Register event
+      #
+      # @param [String] event
+      def on event, &block
+        @on_blocks ||= {}
+        @on_blocks[event] = block
+      end
+
+      # Register event once
+      #
+      # @param [String] event
+      def once event, &block
+        @once_blocks ||= {}
+        @once_blocks[event] = block
+      end
+
+      # Emit event
+      def emit *args
+        event = args.shift
+        if @once_blocks && block = @once_blocks[event]
+          @once_blocks.delete event
+        elsif !@on_blocks || !block = @on_blocks[event]
+          return
+        end
+        block.call *args
+      end
+    end
+  end
+end

data/lib/citrus-rpc/version.rb

@@ -0,0 +1,7 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+module CitrusRpc
+  VERSION = '0.0.2'
+end

data/spec/mock-remote/area/add_one_remote.rb

@@ -0,0 +1,13 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+class AddOneRemote < Citrus::AppRemote
+  def do value, &block
+    block.call nil, value + 1
+  end
+
+  def add_two value, &block
+    block.call nil, value + 2
+  end
+end

data/spec/mock-remote/area/add_three_remote.rb

@@ -0,0 +1,9 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+class AddThreeRemote < Citrus::AppRemote
+  def do value, &block
+    block.call nil, value + 3
+  end
+end

data/spec/mock-remote/area/who_am_i_remote.rb

@@ -0,0 +1,9 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+class WhoAmIAreaRemote < Citrus::AppRemote
+  def do &block
+    block.call nil, @app[:server_id]
+  end
+end

data/spec/mock-remote/connector/who_am_i_remote.rb

@@ -0,0 +1,9 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+class WhoAmIRemote < Citrus::AppRemote
+  def do &block
+    block.call nil, @app[:server_id]
+  end
+end

data/spec/rpc-client/client_spec.rb

@@ -0,0 +1,166 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Client do
+
+  dirname = File.expand_path File.dirname(__FILE__)
+  records = [
+    { :namespace => 'user', :server_type => 'area', :path => dirname + '/../mock-remote/area' },
+    { :namespace => 'sys', :server_type => 'connector', :path => dirname + '/../mock-remote/connector' }
+  ]
+
+  server_list = [
+    { :id => 'area-server-1', :server_type => 'area', :host => '127.0.0.1', :port => 3333 },
+    { :id => 'connector-server-1', :server_type => 'connector', :host => '127.0.0.1', :port => 4444 },
+    { :id => 'connector-server-2', :server_type => 'connector', :host => '127.0.0.1', :port => 5555 }
+  ]
+
+  describe '#create' do
+    it 'should be ok when created with empty options' do
+      client = Client.new
+      expect(client).to be_an_instance_of Client
+
+      EM.run {
+        client.start { |err|
+          expect(err).to be_nil
+          client.stop true
+        }
+
+        EM.add_timer(0.1) { EM.stop_event_loop }
+      }
+    end
+
+    it 'should add proxies by add_proxies method' do
+      client = Client.new
+      expect(client).to be_an_instance_of Client
+
+      client.add_proxies records
+      records.each { |record|
+        namespace = record[:namespace]
+        server_type = record[:server_type]
+        expect(client.proxies).to respond_to namespace
+        expect(client.proxies[namespace]).to respond_to server_type
+      }
+    end
+
+    it 'should replace the default router when created by passing router argument' do
+      route_count = 0
+      callback_count = 0
+
+      server = server_list[1]
+      server_id = server[:id]
+
+      router = Proc.new do |route_param, msg, route_context, &block|
+        route_count = route_count + 1
+        block.call nil, server_id
+      end
+
+      EM.run {
+        server_list.each { |server|
+          Server.new( :records => records, :port => server[:port],
+            :context => { :server_id => server[:id] }).start
+        }
+
+        client = Client.new :router => router
+        client.add_proxies records
+        client.add_server server
+
+        client.start { |err|
+          expect(err).to be_nil
+
+          client.proxies.sys.connector.whoAmIRemote.do(nil) { |err, sid|
+            callback_count = callback_count + 1
+            expect(sid).to eq server_id
+          }
+        }
+
+        EM.add_timer(0.1) {
+          expect(route_count).to eq 1
+          expect(callback_count).to eq 1
+          EM.stop_event_loop
+        }
+      }
+    end
+  end
+
+  describe '#status' do
+    it 'should return an error if started twice' do
+      client = Client.new
+      EM.run {
+        client.start { |err|
+          expect(err).to be_nil
+          client.start { |err|
+            expect(err).to be
+          }
+        }
+
+        EM.add_timer(0.1) { EM.stop_event_loop }
+      }
+    end
+
+    it 'should ignore the later operation if stopped twice' do
+      client = Client.new
+      EM.run {
+        client.start { |err|
+          expect(err).to be_nil
+          client.stop
+          client.stop
+        }
+
+        EM.add_timer(0.1) { EM.stop_event_loop }
+      }
+    end
+
+    it 'should return an error when doing rpc invoke with the client not started' do
+      client = Client.new
+      EM.run {
+        client.rpc_invoke(server_list[0][:id], '') { |err|
+          expect(err).to be
+        }
+
+        EM.add_timer(0.1) { EM.stop_event_loop }
+      }
+    end
+
+    it 'should return an error when doing rpc invoke after the client stopped' do
+      server_id = server_list[0][:id]
+
+      client = Client.new
+      client.add_server server_list[0]
+
+      EM.run {
+        server_list.each { |server|
+          Server.new( :records => records, :port => server[:port],
+            :context => { :server_id => server[:id] }).start
+        }
+
+        msg = {
+          'namespace' => 'user',
+          'server_type' => 'area',
+          'service' => 'whoAmIAreaRemote',
+          'method' => 'do',
+          'args' => []
+        };
+
+        client.start { |err|
+          expect(err).to be_nil
+
+          client.rpc_invoke(server_id, msg) { |err|
+            expect(err).to be_nil
+            client.stop true
+            EM.add_timer(0.1) {
+              client.rpc_invoke(server_id, msg) { |err|
+                expect(err).to be
+              }
+            }
+          }
+        }
+
+        EM.add_timer(0.2) { EM.stop_event_loop }
+      }
+    end
+  end
+end

data/spec/rpc-client/mailstaion_spec.rb

@@ -0,0 +1,235 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe MailStation do
+
+  dirname = File.expand_path File.dirname(__FILE__)
+  records = [
+    { :namespace => 'user', :server_type => 'area', :path => dirname + '/../mock-remote/area' },
+    { :namespace => 'sys', :server_type => 'connector', :path => dirname + '/../mock-remote/connector' }
+  ]
+
+  server_list = [
+    { :id => 'area-server-1', :server_type => 'area', :host => '127.0.0.1', :port => 3333 },
+    { :id => 'connector-server-1', :server_type => 'connector', :host => '127.0.0.1', :port => 4444 },
+    { :id => 'connector-server-2', :server_type => 'connector', :host => '127.0.0.1', :port => 5555 }
+  ]
+
+  msg = {
+    'namespace' => 'user',
+    'server_type' => 'area',
+    'service' => 'whoAmIAreaRemote',
+    'method' => 'do',
+    'args' => []
+  }
+
+  describe '#create' do
+    it 'should be ok when created with empty options' do
+      EM.run {
+        station = MailStation.new
+        expect(station).to be
+
+        station.start { |err|
+          expect(err).to be_nil
+          EM.stop_event_loop
+        }
+      }
+    end
+
+    it 'should change the default mailbox class by passing mailbox class argument' do
+      MockMailBox = Class.new
+
+      station = MailStation.new :mailbox_class => MockMailBox
+      expect(station).to be
+      expect(station.mailbox_class).to eql MockMailBox
+    end
+  end
+
+  describe '#add server' do
+    it 'should add server info into the mail station' do
+      station = MailStation.new
+      expect(station).to be
+
+      server_list.each { |server|
+        station.add_server server
+      }
+
+      servers = station.servers
+      server_list.each { |item|
+        server = servers[item[:id]]
+        expect(server).to be
+        expect(server).to eql item
+      }
+    end
+  end
+
+  describe '#dispatch' do
+    it 'should send the request to the right remote server and get the response from callback' do
+      callback_count = 0
+      count = 0
+
+      station = MailStation.new
+      expect(station).to be
+
+      server_list.each { |server|
+        station.add_server server
+      }
+
+      EM.run do
+        server_list.each { |server|
+          Server.new(
+            :records => records,
+            :port => server[:port],
+            :context => { :server_id => server[:id] }
+          ).start
+        }
+
+        func = Proc.new { |server_id|
+          Proc.new { |err, remote_id|
+            expect(remote_id).to be
+            expect(remote_id).to eql server_id
+            callback_count = callback_count + 1
+          }
+        }
+
+        station.start { |err|
+          server_list.each { |server|
+            count = count + 1
+            station.dispatch server[:id], msg, nil, func.call(server[:id])
+          }
+        }
+
+        EM.add_timer(0.1) {
+          expect(callback_count).to eql count
+          EM.stop_event_loop
+        }
+      end
+    end
+
+    it 'should update the mailbox map by add server after start' do
+      callback_count = 0
+      count = 0
+
+      station = MailStation.new
+      expect(station).to be
+
+      server_list.each { |server|
+        station.add_server server
+      }
+
+      EM.run {
+        server_list.each { |server|
+          Server.new(
+            :records => records,
+            :port => server[:port],
+            :context => { :server_id => server[:id] }
+          ).start
+        }
+
+        server = server_list[0]
+
+        block = Proc.new { |err, remote_id|
+          expect(remote_id).to be
+          expect(remote_id).to eql server[:id]
+          callback_count = callback_count + 1
+        }
+
+        station.start { |err|
+          station.add_server server
+          station.dispatch server[:id], msg, nil, block
+        }
+
+        EM.add_timer(0.1) {
+          expect(callback_count).to eql 1
+          EM.stop_event_loop
+        }
+      }
+    end
+  end
+
+  describe '#close' do
+    it 'should emit a close event for each mailbox close' do
+      close_event_count = 0
+
+      server_ids = []
+      mailbox_ids = []
+
+      station = MailStation.new
+      expect(station).to be
+
+      EM.run {
+        server_list.each { |server|
+          Server.new(
+            :records => records,
+            :port => server[:port],
+            :context => { :server_id => server[:id] }
+          ).start
+
+          station.add_server server
+
+          server_ids << server[:id]
+        }
+
+        server_ids.sort
+
+        func = Proc.new { |server_id|
+          Proc.new { |err, remote_id|
+            expect(remote_id).to be
+            expect(remote_id).to eql server_id
+          }
+        }
+
+        station.start { |err|
+          server_list.each { |server|
+            station.dispatch server[:id], msg, nil, func.call(server[:id])
+          }
+          station.on(:close) { |mailbox_id|
+            mailbox_ids << mailbox_id
+            close_event_count = close_event_count + 1
+          }
+        }
+
+        EM.add_timer(0.1) {
+          station.stop true
+          EM.add_timer(0.1) {
+            expect(close_event_count).to eql server_ids.length
+            mailbox_ids.sort
+            expect(mailbox_ids).to eql server_ids
+            EM.stop_event_loop
+          }
+        }
+      }
+    end
+
+    it 'should return an error when trying to dispatch message with a closed station' do
+      error_count = 0
+
+      station = MailStation.new
+      expect(station).to be
+
+      server_list.each { |server|
+        station.add_server server
+      }
+
+      EM.run do
+        station.start { |err|
+          station.stop
+          server_list.each { |server|
+            station.dispatch server[:id], msg, nil, proc{ |err, remote_id|
+              expect(err).to be
+              error_count = error_count + 1
+            }
+          }
+        }
+
+        EM.add_timer(0.1) {
+          expect(error_count).to eql server_list.length
+          EM.stop_event_loop
+        }
+      end
+    end
+  end
+end