arachni-rpc-em 0.1.2 → 0.1.3dev1

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 # ChangeLog
 
-## Version 0.1.2 _(Under development)_
+## Version 0.1.3 (_Under development_)
 
-- Code cleanup
-- Client retries on Errno::ECONNREFUSED
+- Stopped client callbacks from being deferred.
+- Server now supports a fallback serializer to allow clients to use a secondary serializer if they so choose.
+- Client request-retry strategy tweaked to be more resilient.
+
+## Version 0.1.2
+
+- Code cleanup.
+- Client retries on Errno::ECONNREFUSED.

data/README.md

@@ -2,7 +2,7 @@
 <table>
     <tr>
         <th>Version</th>
-        <td>0.1.2</td>
+        <td>0.1.3dev</td>
     </tr>
     <tr>
         <th>Github page</th>
@@ -38,11 +38,14 @@ Arachni-RPC EM is an implementation of the <a href="http://github.com/Arachni/ar
 
 It's capable of:
 
- - performing and handling a few thousand requests per second (depending on call size, network conditions and the like)
- - TLS encryption (with peer verification)
- - asynchronous and synchronous requests
- - handling server-side asynchronous calls that require a block (or any method that requires a block in general)
- - token-based authentication
+ - Performing and handling a few thousand requests per second (depending on call size, network conditions and the like).
+ - Configurable retry-on-fail for requests.
+ - TLS encryption (with peer verification).
+ - Asynchronous and synchronous requests.
+ - Handling server-side asynchronous calls that require a block (or any method that passes its result to a block instead of returning it).
+ - Token-based authentication.
+ - Primary and secondary (fallback) serializers -- Server will expect the Client to use the primary serializer,
+    if the Request cannot be parsed using the primary one, it will revert to using the fallback to parse the Request and serialize the Response.
 
 ## Usage
 

data/Rakefile

@@ -19,7 +19,7 @@ rescue LoadError => e
     puts '  gem install rspec'
 end
 
-task default: [ :spec ]
+task default: [ :build, :spec ]
 
 desc "Generate docs"
 task :docs do
@@ -48,12 +48,12 @@ end
 
 desc "Build and install the arachni gem."
 task :install  => [ :build ] do
-
     sh "gem install arachni-rpc-em-#{Arachni::RPC::EM::VERSION}.gem"
 end
 
-desc "Push a new version to Gemcutter"
+desc "Push a new version to Rubygems"
 task :publish => [ :build ] do
-
+    sh "git tag -a v#{Arachni::RPC::EM::VERSION} -m 'Version #{Arachni::RPC::EM::VERSION}'"
     sh "gem push arachni-rpc-em-#{Arachni::RPC::EM::VERSION}.gem"
 end
+task :release => [ :publish ]

data/examples/client.EM.run.rb

@@ -19,19 +19,17 @@ require File.join( File.expand_path( File.dirname( __FILE__ ) ), '../lib/arachni
 
     # connect to the server
     client = Arachni::RPC::EM::Client.new(
-        :host  => 'localhost',
-        :port  => 7332,
+        host:       'localhost',
+        port:       7332,
 
         # optional authentication token, if it doesn't match the one
         # set on the server-side you'll be getting exceptions.
-        :token => 'superdupersecret',
-
-        # :keep_alive => false,
+        token:      'superdupersecret',
 
         # optional serializer (defaults to YAML)
         # see the 'serializer' method at:
         # http://eventmachine.rubyforge.org/EventMachine/Protocols/ObjectProtocol.html#M000369
-        :serializer => Marshal
+        serializer: Marshal
     )
 
     bench = Arachni::RPC::RemoteObjectMapper.new( client, 'bench' )
@@ -65,49 +63,14 @@ require File.join( File.expand_path( File.dirname( __FILE__ ) ), '../lib/arachni
     end
 
     # async calls are the same
-    bench.foo( 'This is an async call... business as usual. :)' ) {
-        |res|
+    bench.foo( 'This is an async call... business as usual. :)' ) do |res|
         p res
         # => "This is an async call... business as usual. :)"
-    }
+    end
 
-    bench.async_foo( 'This is an async call to an async remote method.' ) {
-        |res|
+    bench.async_foo( 'This is an async call to an async remote method.' ) do |res|
         p res
         # => "This is an async call to an async remote method."
-    }
-
-
-    #
-    # The system uses 2 methods to make calls appear sync:
-    #   - Threads (when the code is *not* run directly inside the Reactor's thread, see example.rb)
-    #   - Fibers (when the code *is* run inside the Reactor's thread, like right here)
-    #
-    # For performance reasons callbacks are ::EM.defer'ed.
-    #
-    # This means that they're already in their own thread so you don't need
-    # ::Arachni::RPC::EM::EM::Synchrony.run to perform sync calls from inside callbacks.
-    #
-    bench.async_foo( 'Coo-coo' ) {
-        |res|
-
-        p res
-        # => "Coo-coo"
-
-        p bench.async_foo( 'Coo-coo 2' )
-        # => "Coo-coo 2"
-
-        bench.async_foo( 'Coo-coo 3' ) {
-            |res|
-
-            p res
-            # => "Coo-coo 3"
-
-            p bench.foo( 'Coo-coo 4' )
-            # => "Coo-coo 4"
-        }
-
-    }
-
+    end
 
 end

data/examples/client.rb

@@ -14,45 +14,30 @@ require File.join( cwd, '../lib/arachni/rpc/', 'em' )
 
 # connect to the server
 client = Arachni::RPC::EM::Client.new(
-    :host  => 'localhost',
-    :port  => 7332,
+    host:       'localhost',
+    port:       7332,
 
     # optional authentication token, if it doesn't match the one
     # set on the server-side you'll be getting exceptions.
-    :token => 'superdupersecret',
+    token:      'superdupersecret',
 
     # optional serializer (defaults to YAML)
     # see the 'serializer' method at:
     # http://eventmachine.rubyforge.org/EventMachine/Protocols/ObjectProtocol.html#M000369
-    :serializer => Marshal,
-
-    #
-    # Connection keep alive is set to true by default, this means that
-    # a single connection will be maintained and all calls will pass
-    # through it.
-    # This bypasses a bug in EventMachine and allows you to perform thousands
-    # of calls without issue.
-    #
-    # However, you are responsible for closing the connection when you're done.
-    #
-    # If keep alive is set to false then each call will go through its own connection
-    # and the responsibility for closing that connection falls on Arachni-RPC.
-    #
-    # Unfortunately, if you try to make a greater number of calls than your system's
-    # maximum open file descriptors limit EventMachine will freak-out.
     #
-    :keep_alive => false,
+    # Will trigger the Server's fallback serializer.
+    serializer: YAML,
 
     #
     # In order to enable peer verification one must first provide
     # the following:
     #
     # SSL CA certificate
-    # :ssl_ca     => cwd + '/../spec/pems/cacert.pem',
+    # ssl_ca:   cwd + '/../spec/pems/cacert.pem',
     # SSL private key
-    # :ssl_pkey   => cwd + '/../spec/pems/client/key.pem',
+    # ssl_pkey: cwd + '/../spec/pems/client/key.pem',
     # SSL certificate
-    # :ssl_cert   => cwd + '/../spec/pems/client/cert.pem'
+    # ssl_cert: cwd + '/../spec/pems/client/cert.pem'
 )
 
 # Make things easy on the eyes using the mapper, it allows you to do this:
@@ -69,9 +54,7 @@ bench = Arachni::RPC::RemoteObjectMapper.new( client, 'bench' )
 # In order to perform an asynchronous call you will need to provide a block,
 # even if it is an empty one.
 #
-bench.foo( 'This is an async call to "bench.foo".' ) {
-    |res|
-
+bench.foo( 'This is an async call to "bench.foo".' ) do |res|
     p res
     # => "This is an async call to \"bench.foo\"."
 
@@ -98,7 +81,7 @@ bench.foo( 'This is an async call to "bench.foo".' ) {
     # was there an authentication token mismatch?
     # p res.rpc_invalid_token_error?
     # => false
-}
+end
 
 
 
@@ -108,11 +91,10 @@ bench.foo( 'This is an async call to "bench.foo".' ) {
 # You'll need to kind-of specify the async methods on the server-side,
 # check the server example file for more info.
 #
-bench.async_foo( 'This is an async call to "bench.async_foo".' ) {
-    |res|
+bench.async_foo( 'This is an async call to "bench.async_foo".' ) do |res|
     p res
     # => "This is an async call to \"bench.async_foo\"."
-}
+end
 
 p bench.async_foo( 'This is a sync call to "bench.async_foo".' )
 # => "This is a sync call to \"bench.async_foo\"."
@@ -141,7 +123,7 @@ p bench.foo( 'This is a sync call to "bench.foo".' )
 blah = Arachni::RPC::RemoteObjectMapper.new( client, 'blah' )
 begin
     p blah.something
-rescue Exception => e
+rescue => e
     p e  # => #<Arachni::RPC::EM::Exceptions::InvalidObject: Trying to access non-existent object 'blah'.>
 end
 
@@ -150,7 +132,7 @@ end
 #
 begin
     p bench.fdoo
-rescue Exception => e
+rescue => e
     p e # => #<Arachni::RPC::EM::Exceptions::InvalidMethod: Trying to access non-public method 'fdoo'.>
 end
 
@@ -161,8 +143,7 @@ end
 # It will *NOT* be thrown!
 # It will be *RETURNED*!
 #
-blah.something {
-    |res|
+blah.something do |res|
     p res # => #<Arachni::RPC::EM::Exceptions::InvalidObject: Trying to access non-existent object 'blah'.>
 
     # RPC Exception helper methods have been added to all Ruby objects (except BasicObject)
@@ -170,12 +151,12 @@ blah.something {
 
     # p res.rpc_exception? # => true
     # p res.rpc_invalid_object_error? # => true
-}
+end
 
 #
 # We don't know when async calls will return so we wait forever.
 #
 # Call ::EM.stop to break-out.
 #
-Arachni::RPC::EM.block!
+Arachni::RPC::EM.block
 

data/examples/server.rb

@@ -13,7 +13,7 @@ require File.join( cwd, '../lib/arachni/rpc/', 'em' )
 
 class Parent
     def foo( arg )
-        return arg
+        arg
     end
 end
 
@@ -38,22 +38,27 @@ class Bench < Parent
 end
 
 server = Arachni::RPC::EM::Server.new(
-    :host  => 'localhost',
-    :port  => 7332,
+    host:       'localhost',
+    port:       7332,
 
     # optional authentication token, if it doesn't match the one
     # set on the client-side the client won't be able to do anything
     # and keep getting exceptions.
-    :token => 'superdupersecret',
+    token:      'superdupersecret',
 
     # optional serializer (defaults to YAML)
     # see the 'serializer' method at:
     # http://eventmachine.rubyforge.org/EventMachine/Protocols/ObjectProtocol.html#M000369
-    :serializer => Marshal,
+    #
+    # Use Marshal for performance as the primary serializer.
+    serializer: Marshal,
+
+    # Fallback to YAML for interoperability -- used for requests that can't be parsed by Marshal.load.
+    fallback_serializer: YAML,
 
-    # :ssl_ca     => cwd + '/../spec/pems/cacert.pem',
-    # :ssl_pkey   => cwd + '/../spec/pems/server/key.pem',
-    # :ssl_cert   => cwd + '/../spec/pems/server/cert.pem'
+    # ssl_ca:   cwd + '/../spec/pems/cacert.pem',
+    # ssl_pkey: cwd + '/../spec/pems/server/key.pem',
+    # ssl_cert: cwd + '/../spec/pems/server/cert.pem'
 )
 
 #
@@ -64,15 +69,14 @@ server = Arachni::RPC::EM::Server.new(
 # you can just decide dynamically based on a plethora of data which Ruby provides
 # by its 'Method' class.
 #
-server.add_async_check {
-    |method|
+server.add_async_check do |method|
     #
     # Must return 'true' for async and 'false' for sync.
     #
     # Very simple check here...
     #
-    'async' ==  method.name.to_s.split( '_' )[0]
-}
+    method.name.to_s.start_with? 'async_'
+end
 
 server.add_handler( 'bench', Bench.new )
 

data/lib/arachni/rpc/em/client.rb

@@ -14,7 +14,8 @@ module EM
 # Simple EventMachine-based RPC client.
 #
 # It's capable of:
-# - performing and handling a few thousands requests per second (depending on call size, network conditions and the like)
+# - performing and handling a few thousands requests per second (depending on
+#   call size, network conditions and the like)
 # - TLS encryption
 # - asynchronous and synchronous requests
 # - handling remote asynchronous calls that require a block
@@ -39,10 +40,12 @@ class Client
         DEFAULT_TRIES = 9
 
         def initialize( opts )
-            @opts = opts
+            @opts = opts.dup
+
             @max_retries = @opts[:max_retries] || DEFAULT_TRIES
+
             @opts[:tries] ||= 0
-            @tries = @opts[:tries]
+            @tries ||= @opts[:tries]
 
             @status = :idle
 
@@ -58,14 +61,15 @@ class Client
         def unbind( reason )
             end_ssl
 
-            if @request && @request.callback && status != :done
-                if reason == Errno::ECONNREFUSED && retry?
+            if @request && @request.callback && !done?
+                if retry? #&& reason == Errno::ECONNREFUSED
                     retry_request
                 else
                     e = Arachni::RPC::Exceptions::ConnectionError.new( "Connection closed [#{reason}]" )
                     @request.callback.call( e )
                 end
             end
+
             @status = :closed
         end
 
@@ -77,42 +81,37 @@ class Client
             @status
         end
 
+        def done?
+            !!@done
+        end
+
         #
         # Used to handle responses.
         #
         # @param    [Arachni::RPC::EM::Response]    res
         #
         def receive_response( res )
-            @status = :done
-
             if exception?( res )
                 res.obj = Arachni::RPC::Exceptions.from_response( res )
             end
 
-
-            if cb = @request.callback
-
-                callback = Proc.new do |obj|
-                    cb.call( obj )
-                    close_connection
-                end
-
-                if @request.defer?
-                    # the callback might block a bit so tell EM to put it in a thread
-                    ::EM.defer { callback.call( res.obj ) }
-                else
-                    callback.call( res.obj )
-                end
-            end
+            @request.callback.call( res.obj ) if @request.callback
+        ensure
+            @done = true
+            @status = :done
+            close_connection
         end
 
         def retry_request
             opts = @opts.dup
             opts[:tries] += 1
-            EventMachine::Timer.new( 0.1 ){
-                sleep( 0.1 )
-                close_connection
-                ::EM.connect( opts[:host], opts[:port], self.class, opts ).send_request( @request )
+
+            @tries += 1
+            ::EM.next_tick {
+                ::EM::Timer.new( 0.2 ) {
+                    ::EM.connect( opts[:host], opts[:port], self.class, opts ).
+                        send_request( @request )
+                }
             }
         end
 
@@ -131,9 +130,9 @@ class Client
         # @param    [Arachni::RPC::EM::Request]      req
         #
         def send_request( req )
-            @status = :pending
             @request = req
             super( req )
+            @status = :pending
         end
     end
 
@@ -162,6 +161,9 @@ class Client
     #        # http://eventmachine.rubyforge.org/EventMachine/Protocols/ObjectProtocol.html#M000369
     #        :serializer => Marshal,
     #
+    #        # serializer to use if the first choice fails
+    #        :fallback_serializer => YAML,
+    #
     #        :max_retries => 0,
     #
     #        #
@@ -179,18 +181,12 @@ class Client
     # @param    [Hash]  opts
     #
     def initialize( opts )
-        begin
-            @opts  = opts.merge( role: :client )
-            @token = @opts[:token]
+        @opts  = opts.merge( role: :client )
+        @token = @opts[:token]
 
-            @host, @port = @opts[:host], @opts[:port]
+        @host, @port = @opts[:host], @opts[:port].to_i
 
-            Arachni::RPC::EM.ensure_em_running
-        rescue EventMachine::ConnectionError => e
-            exc = ConnectionError.new( e.to_s + " for '#{@k}'." )
-            exc.set_backtrace( e.backtrace )
-            raise exc
-        end
+        Arachni::RPC::EM.ensure_em_running
     end
 
     #
@@ -201,10 +197,9 @@ class Client
     # To perform an async call you need to provide a block which will be passed
     # the return value once the method has finished executing.
     #
-    #    server.call( 'handler.method', arg1, arg2 ){
-    #        |res|
+    #    server.call( 'handler.method', arg1, arg2 ) do |res|
     #        do_stuff( res )
-    #    }
+    #    end
     #
     #
     # To perform a sync (blocking) call do not pass a block, the value will be
@@ -224,11 +219,7 @@ class Client
             token:    @token
         )
 
-        if block_given?
-            call_async( req )
-        else
-            call_sync( req )
-        end
+        block_given? ? call_async( req ) : call_sync( req )
     end
 
     private
@@ -238,7 +229,7 @@ class Client
     end
 
     def call_async( req, &block )
-        ::EM.schedule {
+        ::EM.next_tick {
             req.callback = block if block_given?
             connect.send_request( req )
         }
@@ -257,10 +248,6 @@ class Client
             end
             sleep
         else
-            # Fibers do not work across threads so don't defer the callback
-            # once the Handler gets to it
-            req.do_not_defer
-
             f = Fiber.current
             call_async( req ) { |obj| f.resume( obj ) }