arachni-rpc-em 0.1.3 → 0.2

data/lib/arachni/rpc/em/server/handler.rb

@@ -0,0 +1,161 @@
+=begin
+
+    This file is part of the Arachni-RPC EM project and may be subject to
+    redistribution and commercial restrictions. Please see the Arachni-RPC EM
+    web site for more information on licensing and terms of use.
+
+=end
+
+module Arachni
+module RPC::EM
+class Server
+
+#
+# Receives `Arachni::RPC::Request` objects and transmits `Arachni::RPC::Response`
+# objects.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+#
+class Handler < EventMachine::Connection
+    include Protocol
+    include ConnectionUtilities
+    include ::Arachni::RPC::Exceptions
+
+    #INACTIVITY_TIMEOUT = 10
+
+    # @return   [Arachni::RPC::Request] Working RPC request.
+    attr_reader :request
+
+    # @param    [Server]    server  RPC server.
+    def initialize( server )
+        super
+
+        @server  = server
+        @opts    = server.opts.dup
+        @request = nil
+
+        assume_server_role!
+
+        # Do not tolerate long periods of inactivity in order to avoid zombie
+        # connections.
+        #set_comm_inactivity_timeout( INACTIVITY_TIMEOUT )
+    end
+
+    # Initializes an SSL session once the connection has been established.
+    #
+    # @private
+    def post_init
+        start_ssl
+    end
+
+    # Handles closed connections and cleans up the SSL session.
+    #
+    # @private
+    def unbind
+        end_ssl
+        @server = nil
+    end
+
+    #
+    # * Handles a `Arachni::RPC::Request`
+    # * Sets the {#request}.
+    # * Sends back a `Arachni::RPC::Response`.
+    #
+    # @param    [Arachni::RPC::EM::Request]     req
+    #
+    def receive_request( req )
+        @request = req
+
+        # Create an empty response to be filled in little by little.
+        res  = ::Arachni::RPC::Response.new
+        peer = peer_ip_addr
+
+        begin
+            # Make sure the client is allowed to make RPC calls.
+            authenticate!
+
+            # Grab the partially filled in response which includes the result
+            # of the RPC call and merge it with out prepared response.
+            res.merge!( @server.call( self ) )
+
+        # Handle exceptions and convert them to a simple hash, ready to be
+        # passed to the client.
+        rescue Exception => e
+            type = ''
+
+            # If it's an RPC exception pass the type along as is...
+            if e.rpc_exception?
+                type = e.class.name.split( ':' )[-1]
+
+            # ...otherwise set it to a RemoteException.
+            else
+                type = 'RemoteException'
+            end
+
+            # RPC conventions for exception transmission.
+            res.obj = {
+                'exception' => e.to_s,
+                'backtrace' => e.backtrace,
+                'type'      => type
+            }
+
+            msg = "#{e.to_s}\n#{e.backtrace.join( "\n" )}"
+            @server.logger.error( 'Exception' ){ msg + " [on behalf of #{peer}]" }
+        end
+
+        # Pass the result of the RPC call back to the client but *only* if it
+        # wasn't async, otherwise {Server#call} will have already taken care of it
+        send_response( res ) if !res.async?
+    end
+
+    private
+
+    # @param    [Symbol]    severity    Severity of the logged event:
+    #   * `:debug`
+    #   * `:info`
+    #   * `:warn`
+    #   * `:error`
+    #   * `:fatal`
+    #   * `:unknown`
+    #
+    # @param    [String]    category    Category of message (SSL, Call, etc.).
+    # @param    [String]    msg Message to log.
+    #
+    def log( severity, category, msg )
+        sev_sym = Logger.const_get( severity.to_s.upcase.to_sym )
+        @server.logger.add( sev_sym, msg, category )
+    end
+
+    #
+    # Authenticates the client based on the token in the request.
+    #
+    # It will raise an exception if the token doesn't check-out.
+    #
+    def authenticate!
+        if !valid_token?( @request.token )
+
+            msg = 'Token missing or invalid while calling: ' + @request.message
+
+            @server.logger.error( 'Authenticator' ){
+                msg + " [on behalf of #{peer_ip_addr}]"
+            }
+
+            fail InvalidToken.new( msg )
+        end
+    end
+
+    #
+    # Compares the authentication token in the param with the one of the server.
+    #
+    # @param    [String]    token
+    #
+    # @return   [Bool]
+    #
+    def valid_token?( token )
+        token == @server.token
+    end
+
+end
+end
+end
+end

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

@@ -9,7 +9,7 @@
 module Arachni
 module RPC
 module EM
-    VERSION = '0.1.3'
+    VERSION = '0.2'
 end
 end
 end

data/spec/arachni/rpc/em/client_spec.rb

@@ -1,4 +1,4 @@
-require File.join( File.expand_path( File.dirname( __FILE__ ) ), '../../../', 'spec_helper' )
+require 'spec_helper'
 
 describe Arachni::RPC::EM::Client do
 
@@ -8,19 +8,20 @@ describe Arachni::RPC::EM::Client do
         ]
     end
 
-    it "should be able to retain stability and consistency under heavy load" do
+    it 'retains stability and consistency under heavy load' do
         client = start_client( rpc_opts )
 
-        n    = 400
-        cnt  = 0
+        n   = 100_000
+        cnt = 0
 
         mismatches = []
 
         n.times do |i|
-            client.call( 'test.foo', i ) do |res|
+            arg = 'a' * i
+            client.call( 'test.foo', arg ) do |res|
                 cnt += 1
-                mismatches << [i, res] if i != res
-                ::EM.stop if cnt == n || !mismatches.empty?
+                mismatches << [i, arg, res] if arg != res
+                ::EM.stop if cnt == n || mismatches.any?
             end
         end
 
@@ -29,24 +30,103 @@ describe Arachni::RPC::EM::Client do
         mismatches.should be_empty
     end
 
-    it "should throw error when connecting to inexistent server" do
-        start_client( rpc_opts.merge( :host => 'dddd', :port => 999339 ) ).call( 'test.foo', @arg ) do |res|
-            res.rpc_connection_error?.should be_true
-            ::EM.stop
+    describe '#initialize' do
+        it 'should be able to properly assign class options (including :role)' do
+            opts = rpc_opts.merge( role: :client )
+            start_client( opts ).opts.should == opts
         end
-        Arachni::RPC::EM.block
 
-        start_client( rpc_opts.merge( :port => 999339 ) ).call( 'test.foo', @arg ) do |res|
-            res.rpc_connection_error?.should be_true
-            ::EM.stop
+        context 'when passed no connection information' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new({})
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
         end
-        Arachni::RPC::EM.block
-    end
 
-    describe "#initialize" do
-        it "should be able to properly assign class options (including :role)" do
-            opts = rpc_opts.merge( :role => :client )
-            start_client( opts ).opts.should == opts
+        describe 'option' do
+            describe :socket do
+                it 'connects to it' do
+                    client = start_client( rpc_opts_with_socket )
+                    client.call( 'test.foo', 1 ).should == 1
+                end
+
+                context 'and connecting to a non-existent server' do
+                    it 'returns Arachni::RPC::Exceptions::ConnectionError' do
+                        options = rpc_opts_with_socket.merge( socket: '/' )
+                        start_client( options ).call( 'test.foo', @arg ) do |res|
+                            res.rpc_connection_error?.should be_true
+                            res.should be_kind_of Arachni::RPC::Exceptions::ConnectionError
+                            ::EM.stop
+                        end
+                        Arachni::RPC::EM.block
+                    end
+                end
+
+                it 'retains stability and consistency under heavy load' do
+                    client = start_client( rpc_opts_with_socket )
+
+                    n    = 100_000
+                    cnt  = 0
+
+                    mismatches = []
+
+                    n.times do |i|
+                        arg = 'a' * i
+                        client.call( 'test.foo', arg ) do |res|
+                            cnt += 1
+                            mismatches << [i, arg, res] if arg != res
+                            ::EM.stop if cnt == n || mismatches.any?
+                        end
+                    end
+
+                    Arachni::RPC::EM.block
+                    cnt.should > 0
+                    mismatches.should be_empty
+                end
+
+                context 'when passed an invalid socket path' do
+                    it 'raises ArgumentError' do
+                        begin
+                            described_class.new( socket: 'blah' )
+                        rescue => e
+                            e.should be_kind_of ArgumentError
+                        end
+                    end
+                end
+            end
+        end
+
+        context 'when passed a host but not a port' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new( host: 'test' )
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
+        end
+
+        context 'when passed a port but not a host' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new( port: 9999 )
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
+        end
+
+        context 'when passed an invalid port' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new( host: 'tt', port: 'blah' )
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
         end
     end
 
@@ -60,18 +140,15 @@ describe Arachni::RPC::EM::Client do
                 start_client( opts ).call( 'test.foo', @arg ).should == @arg
             end
         end
-
     end
 
-    describe "raw interface" do
-
-        context "when using Threads" do
-
-            it "should be able to perform synchronous calls" do
+    describe 'raw interface' do
+        context 'when using Threads' do
+            it 'should be able to perform synchronous calls' do
                 @arg.should == start_client( rpc_opts ).call( 'test.foo', @arg )
             end
 
-            it "should be able to perform asynchronous calls" do
+            it 'should be able to perform asynchronous calls' do
                 start_client( rpc_opts ).call( 'test.foo', @arg ) do |res|
                     @arg.should == res
                     ::EM.stop
@@ -80,9 +157,8 @@ describe Arachni::RPC::EM::Client do
             end
         end
 
-        context "when run inside the Reactor loop" do
-
-            it "should be able to perform synchronous calls" do
+        context 'when run inside the Reactor loop' do
+            it 'should be able to perform synchronous calls' do
                 ::EM.run {
                     ::Arachni::RPC::EM::Synchrony.run do
                         @arg.should == start_client( rpc_opts ).call( 'test.foo', @arg )
@@ -91,7 +167,7 @@ describe Arachni::RPC::EM::Client do
                 }
             end
 
-            it "should be able to perform asynchronous calls" do
+            it 'should be able to perform asynchronous calls' do
                 ::EM.run {
                     start_client( rpc_opts ).call( 'test.foo', @arg ) do |res|
                         res.should == @arg
@@ -103,14 +179,13 @@ describe Arachni::RPC::EM::Client do
         end
     end
 
-    describe "Arachni::RPC::RemoteObjectMapper interface" do
-        it "should be able to properly forward synchronous calls" do
+    describe 'Arachni::RPC::RemoteObjectMapper interface' do
+        it 'should be able to properly forward synchronous calls' do
             test = Arachni::RPC::RemoteObjectMapper.new( start_client( rpc_opts ), 'test' )
             test.foo( @arg ).should == @arg
-            # ::EM.stop
         end
 
-        it "should be able to properly forward synchronous calls" do
+        it 'should be able to properly forward synchronous calls' do
             test = Arachni::RPC::RemoteObjectMapper.new( start_client( rpc_opts ), 'test' )
             test.foo( @arg ) do |res|
                 res.should == @arg
@@ -120,75 +195,110 @@ describe Arachni::RPC::EM::Client do
         end
     end
 
-    describe "exception" do
-        context 'when performing asynchronous calls' do
+    context 'when performing an asynchronous call' do
+        context 'and connecting to a non-existent server' do
+            it 'returns Arachni::RPC::Exceptions::ConnectionError' do
+                options = rpc_opts.merge( host: 'dddd', port: 999339 )
+                start_client( options ).call( 'test.foo', @arg ) do |res|
+                    res.rpc_connection_error?.should be_true
+                    res.should be_kind_of Arachni::RPC::Exceptions::ConnectionError
+                    ::EM.stop
+                end
+                Arachni::RPC::EM.block
+            end
+        end
 
-            it "should be returned when requesting inexistent objects" do
+        context 'and requesting a non-existent object' do
+            it 'returns Arachni::RPC::Exceptions::InvalidObject' do
                 start_client( rpc_opts ).call( 'bar.foo' ) do |res|
                     res.rpc_invalid_object_error?.should be_true
+                    res.should be_kind_of Arachni::RPC::Exceptions::InvalidObject
                     ::EM.stop
                 end
                 Arachni::RPC::EM.block
             end
+        end
 
-            it "should be returned when requesting inexistent or non-public methods" do
+        context 'and requesting a non-public method' do
+            it 'returns Arachni::RPC::Exceptions::InvalidMethod' do
                 start_client( rpc_opts ).call( 'test.bar' ) do |res|
                     res.rpc_invalid_method_error?.should be_true
+                    res.should be_kind_of Arachni::RPC::Exceptions::InvalidMethod
                     ::EM.stop
                 end
                 Arachni::RPC::EM.block
             end
+        end
 
-            it "should be returned when there's a remote exception" do
+        context 'and there is a remote exception' do
+            it 'returns Arachni::RPC::Exceptions::RemoteException' do
                 start_client( rpc_opts ).call( 'test.foo' ) do |res|
                     res.rpc_remote_exception?.should be_true
+                    res.should be_kind_of Arachni::RPC::Exceptions::RemoteException
                     ::EM.stop
                 end
                 Arachni::RPC::EM.block
             end
-
         end
+    end
 
-        context 'when performing synchronous calls' do
-
-            it "should be raised when requesting inexistent objects" do
+    context 'when performing a synchronous call' do
+        #context 'and connecting to a non-existent server' do
+        #    it 'raises Arachni::RPC::Exceptions::ConnectionError' do
+        #        begin
+        #            options = rpc_opts.merge( host: 'dddd', port: 999339 )
+        #            start_client( options ).call( 'test.foo', @arg )
+        #        rescue => e
+        #            e.rpc_connection_error?.should be_true
+        #            e.should be_kind_of Arachni::RPC::Exceptions::ConnectionError
+        #        end
+        #    end
+        #end
+
+        context 'and requesting a non-existent object' do
+            it 'raises Arachni::RPC::Exceptions::InvalidObject' do
                 begin
                     start_client( rpc_opts ).call( 'bar2.foo' )
                 rescue Exception => e
                     e.rpc_invalid_object_error?.should be_true
+                    e.should be_kind_of Arachni::RPC::Exceptions::InvalidObject
                 end
             end
+        end
 
-            it "should be raised when requesting inexistent or non-public methods" do
+        context 'and requesting a non-public method' do
+            it 'raises Arachni::RPC::Exceptions::InvalidMethod' do
                 begin
                     start_client( rpc_opts ).call( 'test.bar2' )
                 rescue Exception => e
                     e.rpc_invalid_method_error?.should be_true
+                    e.should be_kind_of Arachni::RPC::Exceptions::InvalidMethod
                 end
-
             end
+        end
 
-            it "should be raised when there's a remote exception" do
+        context 'and there is a remote exception' do
+            it 'raises Arachni::RPC::Exceptions::RemoteException' do
                 begin
                     start_client( rpc_opts ).call( 'test.foo' )
                 rescue Exception => e
                     e.rpc_remote_exception?.should be_true
+                    e.should be_kind_of Arachni::RPC::Exceptions::RemoteException
                 end
             end
-
         end
     end
 
-    context "when using valid SSL primitives" do
-        it "should be able to establish a connection" do
+    context 'when using valid SSL primitives' do
+        it 'should be able to establish a connection' do
             res = start_client( rpc_opts_with_ssl_primitives ).call( 'test.foo', @arg )
             res.should == @arg
             ::EM.stop
         end
     end
 
-    context "when using invalid SSL primitives" do
-        it "should not be able to establish a connection" do
+    context 'when using invalid SSL primitives' do
+        it 'should not be able to establish a connection' do
             start_client( rpc_opts_with_invalid_ssl_primitives ).call( 'test.foo', @arg ) do |res|
                 res.rpc_connection_error?.should be_true
                 ::EM.stop
@@ -197,8 +307,8 @@ describe Arachni::RPC::EM::Client do
         end
     end
 
-    context "when using mixed SSL primitives" do
-        it "should not be able to establish a connection" do
+    context 'when using mixed SSL primitives' do
+        it 'should not be able to establish a connection' do
             start_client( rpc_opts_with_mixed_ssl_primitives ).call( 'test.foo', @arg ) do |res|
                 res.rpc_connection_error?.should be_true
                 res.rpc_ssl_error?.should be_true