pomelo-citrus-rpc 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: db99b005f4a5fb8e4c52b4667cf4224dff50551c
+  data.tar.gz: d531706c0fa76c8794e9f3d413908de4e83c39b2
+SHA512:
+  metadata.gz: dfa5cc94a9eb7f2414a7f846b8e53e62fede90200c8222d513e543a1aa6f582f4b0350a22b0e3743228820471adcd377b235707ee8170dda943fd4ae30b8293f
+  data.tar.gz: bb25d5530f8224e71647fa3331d21b17c01ed5c0e9536f1f689af4d37ee0a0dce81cde677b9ab46c6f76d2fdaf62b119fa4f1a44fea192f54f5f8fdf882fc540

data/README.md

@@ -0,0 +1,20 @@
+## Welcome to pomelo-citrus-rpc
+
+pomelo-citrus-rpc is a simple clone of pomelo-rpc written in Ruby using EventMachine.
+
+## Motivation
+
+Since NodeJS is influenced by Ruby EventMachine and Python's Twisted model, Ruby should also be able to have its own game server framework like pomelo.
+
+Ruby is a very expressive and eloquent programming language. I was an RoR programmer before and I really like Ruby, When developing this project, I have used many skills like meta-programming and they give me the real pleasures.
+
+Recently, I would focus on my daily work, so I open source this project and hope to have more people participate in this project.
+
+## Todo
+
+This gem is the very first gem I have done in my whole work, it needs to be improved but it already has the ablity to provide the basic infrastructure to other gems, other gems exist in my own repository.
+
+## Links
+
+* [EventMachine](https://github.com/eventmachine/eventmachine)
+* [pomelo-rpc](https://github.com/NetEase/pomelo-rpc)

data/citrus-rpc.gemspec

@@ -0,0 +1,32 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 8 July 2014
+
+$:.push File.expand_path('../lib', __FILE__)
+
+require 'citrus-rpc/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'pomelo-citrus-rpc'
+  spec.version     = CitrusRpc::VERSION
+  spec.platform    = Gem::Platform::RUBY
+  spec.authors     = ['MinixLi']
+  spec.email       = 'MinixLi1986@gmail.com'
+  spec.description = %q{pomelo-citrus-rpc is a simple clone of pomelo-rpc, it provides the infrastructure of RPC between multi-server processes}
+  spec.summary     = %q{pomelo-rpc clone written in Ruby using EventMachine}
+  spec.homepage    = 'https://github.com/minixli/pomelo-citrus-rpc'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency('eventmachine', '~> 0')
+  spec.add_dependency('json', '~> 0')
+  spec.add_dependency('websocket-eventmachine-client', '~> 0')
+  spec.add_dependency('websocket-eventmachine-server', '~> 0')
+
+  spec.add_dependency('pomelo-citrus-loader', '~> 0')
+  spec.add_dependency('pomelo-citrus-logger', '~> 0')
+end

data/example/client.rb

@@ -0,0 +1,43 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../lib/citrus-rpc', __FILE__)
+
+Client = CitrusRpc::RpcClient::Client
+
+dirname = File.expand_path File.dirname(__FILE__)
+record = {
+  :namespace => 'user',
+  :server_type => 'test',
+  :path => dirname + '/remote/test'
+}
+
+servers = [
+  { :id => 'test-server-1', :server_type => 'test', :host => '127.0.0.1', :port => 3333 }
+]
+
+context = { :server_id => 'test-server-1' }
+
+route_context = servers
+
+router = proc{ |route_param, msg, route_context, &block|
+  block.call nil, route_context[0][:id] if block
+}
+
+client = Client.new :context => context, :route_context => route_context, :router => router
+
+client.add_proxy record
+client.add_servers servers
+
+EM.run do
+  client.start do |err|
+    puts 'rpc client started'
+
+    route_param = nil
+    client.proxies.user.test.serviceRemote.echo(route_param, 'hello') do |err, resp|
+      puts err if err
+      puts resp
+    end
+  end
+end

data/example/remote/test/service.rb

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

data/example/server.rb

@@ -0,0 +1,20 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../lib/citrus-rpc', __FILE__)
+
+Server = CitrusRpc::RpcServer::Server
+
+dirname = File.expand_path File.dirname(__FILE__)
+records = [
+  { :namespace => 'user', :path => dirname + '/remote/test' }
+]
+port = 3333
+
+server = Server.new :records => records, :port => port
+
+EM.run do
+  server.start
+  puts 'rpc server started'
+end

data/lib/citrus-rpc.rb

@@ -0,0 +1,16 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 4 July 2014
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'eventmachine'
+require 'json'
+require 'ostruct'
+
+require 'citrus-loader'
+require 'citrus-logger'
+
+require 'citrus-rpc/util/utils'
+require 'citrus-rpc/rpc-client/client'
+require 'citrus-rpc/rpc-server/server'

data/lib/citrus-rpc/rpc-client/client.rb

@@ -0,0 +1,328 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 4 July 2014
+
+require 'citrus-rpc/rpc-client/mailstation'
+require 'citrus-rpc/rpc-client/proxy'
+require 'citrus-rpc/rpc-client/router'
+
+module CitrusRpc
+  # RpcClient
+  #
+  #
+  module RpcClient
+    # Client
+    #
+    # @example
+    #
+    # Create a new rpc client
+    #
+    #  client = CitrusRpc::RpcClient::Client.new
+    #
+    # Add a proxy
+    #
+    #  dirname = File.expand_path File.dirname(__FILE__)
+    #  client.add_proxy(
+    #    :namespace => 'user',
+    #    :server_type => 'test',
+    #    :path => dirname + '/remote/test' # remote service interface path
+    #  )
+    #
+    # Add a remote server
+    #
+    #  client.add_server(
+    #    :server_id => 'test-server-1',
+    #    :server_type => 'test',
+    #    :host => '127.0.0.1',
+    #    :port => 3333
+    #  )
+    #
+    # Do the rpc invoke
+    #
+    #  client.start do |err|
+    #    client.proxies.sys.connector.WhoAmIRemote.do(nil, 'hello') do |err, resp|
+    #      ...
+    #    end
+    #  end
+    #
+    class Client
+      include CitrusLoader
+
+      include Proxy
+      include Router
+
+      attr_reader :proxies
+
+      # Create a new rpc client
+      #
+      # @param [Hash] args Options
+      #
+      # @option args [Object] context
+      # @option args [Object] route_context
+      # @option args [#call]  router
+      # @option args [String] router_type
+      def initialize args={}
+        @args = args
+
+        @context = @args[:context]
+        @route_context = @args[:route_context]
+
+        @router = @args[:router] || method(:df_route)
+        @router_type = @args[:router_type]
+
+        @proxies = OpenStruct.new
+        @station = MailStation.new args
+
+        @state = :state_inited
+      end
+
+      # Start the rpc client which would try to connect the remote servers
+      def start
+        unless @state == :state_inited
+          block_given? and yield Exception.new 'rpc client has started'
+          return
+        end
+
+        @station.start { |err|
+          if err
+            block_given? and yield err
+            return
+          end
+          @state = :state_started
+          block_given? and yield
+        }
+      end
+
+      # Stop the rpc client
+      #
+      # @param [Boolean] force
+      def stop force=false
+        unless @state == :state_started
+          return
+        end
+        @state = :state_closed
+        @station.stop force
+      end
+
+      # Add a new proxy to the rpc client which would override the proxy under
+      # the same key
+      #
+      # @param [Hash] record
+      def add_proxy record
+        return unless record
+
+        proxy = generate_proxy record
+        return unless proxy
+
+        insert_proxy @proxies, record[:namespace], record[:server_type], proxy
+      end
+
+      # Batch version for add_proxy
+      #
+      # @param [Array] records
+      def add_proxies records
+        if records && records.length > 0
+          records.each { |record| add_proxy record }
+        end
+      end
+
+      # Add new remote server to the rpc client
+      #
+      # @param [Hash] server
+      def add_server server
+        @station.add_server server
+      end
+
+      # Batch version for add new remote server
+      #
+      # @param [Array] servers
+      def add_servers servers
+        @station.add_servers servers
+      end
+
+      # Remove remote server from the rpc client
+      #
+      # @param [String] id
+      def remove_server id
+        @station.remove_server id
+      end
+
+      # Batch version for remove remote server
+      #
+      # @param [Array] server_ids
+      def remove_servers ids
+        @station.remove_servers ids
+      end
+
+      # Replace remote servers
+      #
+      # @param [Array] servers
+      def replace_servers servers
+        @station.replace_servers servers
+      end
+
+      # Do the rpc invoke directly
+      #
+      # @param [String] server_id
+      # @param [Hash]   msg
+      def rpc_invoke server_id, msg, &block
+        unless @state == :state_started
+          block_given? and yield Exception.new 'fail to do rpc invoke for client is not running'
+          return
+        end
+        @station.dispatch server_id, msg, @args, block
+      end
+
+      # Add rpc before filter
+      #
+      # @param [#call] filter
+      def before filter
+        @station.before filter
+      end
+
+      # Add rpc after filter
+      #
+      # @param [#call] filter
+      def after filter
+        @station.after filter
+      end
+
+      # Add rpc filter
+      #
+      # @param [#call] filter
+      def filter filter
+        @station.filter filter
+      end
+
+      # Set rpc filter error handler
+      #
+      # @param [#call] handler
+      def set_error_handler handler
+        @station.error_handler = handler
+      end
+
+      private
+
+      # Generate proxies for remote servers
+      #
+      # @param [Hash] record
+      #
+      # @private
+      def generate_proxy record
+        res = OpenStruct.new;
+        remotes = load_app_remote record[:path]
+        remotes.each { |service, remote|
+          res[service] = create_proxy(
+            :remote => remote, :service => service, :attach => record, :proxy_cb => method(:proxy_cb)
+          )
+        }
+        res
+      end
+
+      # Proxy callback
+      #
+      # @param [String]  service
+      # @param [Symbol]  method
+      # @param [Hash]    attach
+      # @param [Boolean] is_to_specified_server
+      #
+      # @private
+      def proxy_cb service, method, attach, is_to_specified_server, *args, &block
+        unless @state == :state_started
+          return
+        end
+        unless args.length > 0
+          return
+        end
+
+        route_param = args.shift
+        server_type = attach[:server_type]
+        msg = { :namespace => attach[:namespace], :server_type => server_type,
+          :service => service, :method => method, :args => args }
+
+        if is_to_specified_server
+          rpc_to_specified_server msg, server_type, route_param, &block
+        else
+          get_route_target(server_type, msg, route_param) { |err, server_id|
+            if err
+              block_given? and block.call err
+            else
+              rpc_invoke server_id, msg, &block
+            end
+          }
+        end
+      end
+
+      # Calculate remote target server id for rpc client
+      #
+      # @param [String] server_type
+      # @param [Hash]   msg
+      # @param [Object] route_param
+      #
+      # @private
+      def get_route_target server_type, msg, route_param, &block
+        if @router_type
+          router = case @router_type
+                   when :roundrobin
+                     method :rr_route
+                   when :weight_roundrobin
+                     method :wrr_route
+                   when :least_active
+                     method :la_route
+                   when :consistent_hash
+                     method :ch_route
+                   else
+                     method :rd_route
+                   end
+          router.call(self, server_type, msg) { |err, server_id|
+            block_given? and yield err, server_id
+          }
+        else
+          unless @router.respond_to? :call
+            block_given? and yield Exception.new 'invalid router method'
+            return
+          end
+          @router.call(route_param, msg, @route_context) { |err, server_id|
+            block_given? and yield err, server_id
+          }
+        end
+      end
+
+      # Rpc to specified server id or servers
+      #
+      # @param [Hash]   msg
+      # @param [String] server_type
+      # @param [String] route_param
+      #
+      # @private
+      def rpc_to_specified_server msg, server_type, route_param, &block
+        unless route_param.instance_of? String
+          return
+        end
+
+        if route_param == '*'
+          @station.servers.each { |server_id, server|
+            if server[:server_type] == server_type
+              rpc_invoke server_id, msg, &block
+            end
+          }
+        else
+          rpc_invoke route_param, msg, &block
+        end
+      end
+      
+      # Add proxy into array
+      #
+      # @param [Object] proxies
+      # @param [String] namespace
+      # @param [String] server_type
+      # @param [Object] proxy
+      #
+      # @private
+      def insert_proxy proxies, namespace, server_type, proxy
+        proxies[namespace] ||= OpenStruct.new
+        proxies[namespace][server_type] = proxy
+      end
+    end
+  end
+end