simplerpc 0.2.0c → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa356f3746316c99d38412a6b6442338df636c06
-  data.tar.gz: 6113c09fea5d80ccc07f1c740f1be02a46d21ba1
+  metadata.gz: fe0eb8578d0b1f0f41f18696580bf8b8bb26439d
+  data.tar.gz: ab97b64f7519ea0b18e9f04c7b7fc52a6206917d
 SHA512:
-  metadata.gz: 5caa01c23100bc3cf6d118668ef6ece8bb1452bc86f4f5ae0d7abfc70aed4cac0f80891b30ab623b3a021cfbf7e9b8625c6f6b3fa3eaeb291828a5cc2eeff07f
-  data.tar.gz: 33830456c160bfe693bb02b79577d001c23ddab85e0244bf49d476c2270a2b5c3db224e4e804197a42ae53b8fb68716424710cdd28b96a63083ebe68ceedd92e
+  metadata.gz: 0152af8e2cff5b277fdb40f02fc18732b14c6a249e33840587a682fc9a7ae9a5867301394ec049eacbed133f321f3d1a1877d982dddf7f9071839c91c5ceed6d
+  data.tar.gz: 6d5ba75c705eb414ae87482f144f638001623b7d6250aa9dec2ee3addc156e862f58ea200ec1d376d818dc41da9374578991d03330016cffd546a5617b591508

data/lib/simplerpc/client.rb

@@ -1,12 +1,26 @@
 require 'socket'      # Sockets are in standard library
 require 'simplerpc/socket_protocol'
 
-module SimpleRPC 
+# rubocop:disable LineLength
 
-  # Exception thrown when the client fails to connect. 
+
+
+module SimpleRPC
+
+  # Exception thrown when the client fails to connect.
   class AuthenticationError < StandardError
   end
 
+  # Thrown when the server raises an exception.
+  #
+  # The message is set to the server's exception class.
+  class RemoteException < Exception
+  end
+
+  # The superclass of a proxy object
+  class RemoteObject < BasicObject
+  end
+
   # The SimpleRPC client connects to a server, either persistently on on-demand, and makes
   # calls to its proxy object.
   #
@@ -14,13 +28,28 @@ module SimpleRPC
   # object, i.e.:
   #
   #   require 'simplerpc/client'
+  #
+  #   # Connect
   #   c = SimpleRPC::Client.new(:hostname => '127.0.0.1', :port => 27045)
-  #   c.length # 2
-  #   c.call(:dup) # ["thing", "thing2"]
-  #   c.close
-  # 
+  #
+  #   # Make some calls directly
+  #   c.length        # 2
+  #   c.call(:dup)    # ["thing", "thing2"]
+  #   c.call(:class)  # Array
+  #
+  #   # Get a proxy object
+  #   p = c.get_proxy
+  #   c.persist     # always-on mode with 1 connection
+  #   p.dup         # ["thing", "thing2"]
+  #   p.length      # 2
+  #   p.class       # Array
+  #   p.each{|x| puts x} # outputs "thing\nthing2\n"
+  #
+  #   # Disconnect from always-on mode
+  #   c.disconnect
+  #
   # == Making Requests
-  # 
+  #
   # Requests can be made on the client object as if it were local, and these will be
   # proxied to the server.  For methods that are clobbered locally (for example '.class',
   # which will return 'SimpleRPC::Client', you may use #call to send this without local
@@ -29,18 +58,56 @@ module SimpleRPC
   #  c.class         # SimpleRPC::Client
   #  c.call(:class)  # Array
   #
-  # The client will throw network errors upon failure, (ERRno::... ), so be sure to catch
-  # these in your application.
+  # === Proxy Objects
+  #
+  # Calling #get_proxy will return a dynamically-constructed object that lacks any methods
+  # other than remote ones---this means it will be almost indistinguishable from a local
+  # object:
+  #
+  #  c.class        # Array
+  #  c.dup          # ['thing', 'thing2']
+  #
+  # This is an exceptionally seamless way of interacting, but you must retain the original
+  # client connection in order to call Client#disconnect or use always-on mode.
+  #
+  # == Blocks
+  #
+  # Blocks are supported and run on the client-side.  A server object may yield any
+  # number of times.  Note that if the client is single-threaded, it is not possible
+  # to call further calls when inside the block (if :threading is on this is perfectly
+  # acceptable).
+  #
+  # == Exceptions
+  #
+  # Remote exceptions fired by the server during a call are wrapped in RemoteException.
+  #
+  # Network errors are exposed directly.  The server will not close a pipe during
+  # an operation, so if using connect-on-demand you should only observe
+  # Errno::ECONNREFUSED exceptions.  If using a persistent connection pool,
+  # you will encounter either Errno::ECONNREFUSED, Errno::ECONNRESET or EOFError as
+  # the serialiser attempts to read from the closed socket.
+  #
+  # == Thread Safety
+  #
+  # Clients are thread-safe and will block when controlling the always-on connection
+  # with #persist and #close.
+  #
+  # If :threaded is true, clients will support multiple connections to the server.  If
+  # used in always-on mode, this means it will maintain one re-usable connection, and only
+  # spawn new ones if requested.
   #
   # == Modes
   #
-  # It is possible to use the client in two modes: _always-on_ and _connect-on-demand_.  
-  # The former of these maintains a single socket to the server, and all requests are
-  # sent over this.  Call #connect and #disconnect to control this connection.
+  # It is possible to use the client in two modes: _always-on_ and _connect-on-demand_,
+  # controlled by calling #connect and #disconnect.
+  #
+  # Always-on mode maintains a pool of connections to the server, and requests
+  # are preferentially sent over these (note that if you have threading off, it makes
+  # no sense to allocate more than one entry in the pool)
   #
-  # The latter establishes a connection when necessary.  This mode is used whenever the
-  # client is not connected, so is a fallback if always-on fails.  There is a small 
-  # performance hit to reconnecting each time.
+  # connect-on-demand creates a connection when necessary.  This mode is used whenever the
+  # client is not connected.  There is a small performance hit to reconnecting each time,
+  # especially if you are using authentication.
   #
   # == Serialisation Formats
   #
@@ -50,7 +117,7 @@ module SimpleRPC
   # The serialiser also supports MessagePack (the msgpack gem), and this yields a small
   # performance increase at the expense of generality (restrictions on data type).
   #
-  # Note that JSON and YAML, though they support reading and writing to sockets, do not 
+  # Note that JSON and YAML, though they support reading and writing to sockets, do not
   # properly terminate their reads and cause the system to hang.  These methods are
   # both slow and limited by comparison anyway, and algorithms needed to support their
   # use require relatively large memory usage.  They may be supported in later versions.
@@ -67,7 +134,7 @@ module SimpleRPC
   # speed) so the results of using mismatched configurations are undefined.
   #
   # The auth process is simple and not particularly secure, but is designed to deter casual
-  # connections and attacks.  It uses a password that is sent encrypted against a salt sent 
+  # connections and attacks.  It uses a password that is sent encrypted against a salt sent
   # by the server to prevent replay attacks.  If you want more reliable security, use an SSH tunnel.
   #
   # The performance impact of auth is small, and takes about the same time as a simple
@@ -75,9 +142,9 @@ module SimpleRPC
   #
   class Client
 
-    attr_reader :hostname, :port
-    attr_accessor :serialiser, :timeout, :fast_auth
-    attr_writer :password, :secret
+    attr_reader     :hostname,    :port,    :threaded
+    attr_accessor   :serialiser,  :timeout, :fast_auth
+    attr_writer     :password,    :secret
 
     # Create a new client for the network.
     # Takes an options hash, in which :port is required:
@@ -88,172 +155,330 @@ module SimpleRPC
     #                I recommend using MessagePack if this is not fast enough
     # [:timeout]     Socket timeout in seconds.
     # [:password] The password clients need to connect
-    # [:secret] The encryption key used during password authentication.  
+    # [:secret] The encryption key used during password authentication.
     #           Should be some long random string that matches the server's.
     # [:fast_auth] Use a slightly faster auth system that is incapable of knowing if it has failed or not.
     #              By default this is off.
+    # [:threaded] Support multiple connections to the server (default is on)
+    #             If off, threaded requests will queue in the client.
     #
     def initialize(opts = {})
 
       # Connection details
       @hostname     = opts[:hostname]   || '127.0.0.1'
       @port         = opts[:port]
-      raise "Port required" if not @port
+      raise 'Port required' unless @port
       @timeout      = opts[:timeout]
 
+      # Support multiple connections at once?
+      @threaded     = !(opts[:threaded] == false)
+
       # Serialiser.
-      @serialiser   = opts[:serialiser] || Marshal 
+      @serialiser   = opts[:serialiser] || Marshal
 
       # Auth system
-      if opts[:password] and opts[:secret] then
+      if opts[:password] && opts[:secret]
         require 'simplerpc/encryption'
         @password   = opts[:password]
         @secret     = opts[:secret]
-      
+
         # Check for return from auth?
         @fast_auth  = (opts[:fast_auth] == true)
       end
 
-      @m = Mutex.new
+      # Threading uses @pool, single thread uses @s and @mutex
+      if @threaded
+        @pool_mutex           = Mutex.new # Controls edits to the pool
+        @pool                 = {}        # List of available sockets with
+                                          # accompanying mutices
+      else
+        @mutex                = Mutex.new
+        @s                    = nil
+      end
     end
 
-    # Connect to the server.  
+    # Connect to the remote server and return two things:
+    #
+    # * A proxy object for communicating with the server
+    # * The client itself, for controlling the connection
     #
-    # Returns true if connected, or false if not.
+    # All options are the same as #new
     #
-    # Note that this is only needed if using the client in always-on mode.
-    def connect
-      @m.synchronize{
-        _connect
-      }
+    def self.new_proxy(opts = {})
+      client = self.new(opts)
+      proxy = client.get_proxy
+
+      return proxy, client
     end
 
-    # Disconnect from the server.
-    def close
-      @m.synchronize{
-        _disconnect
-      }
+    # -------------------------------------------------------------------------
+    # Persistent connection management
+    #
+
+    # Tell the client how many connections to persist.
+    #
+    # If the client is single-threaded, this can either be 1 or 0.
+    # If the client is multi-threaded, it can be any positive integer 
+    # value (or 0).
+    #
+    # #persist(0) is equivalent to #disconnect.
+    def persist(pool_size = 1)
+
+      # Check the pool size is positive
+      raise 'Invalid pool size requested' if pool_size < 0
+
+      # If not threaded, check pool size is valid and connect/disconnect
+      # single socket
+      unless @threaded
+        raise 'Threading is disabled: pool size must be 1' if pool_size > 1
+
+        # Set socket up
+        @mutex.synchronize do
+          if pool_size == 0
+            _disconnect(@s)
+            @s = nil
+          else
+            @s  = _connect
+          end
+        end
+
+        return
+      end
+
+      # If threaded, create a pool of sockets instead
+      @pool_mutex.synchronize do
+
+        # Resize the pool
+        if pool_size > @pool.length
+
+          # Allocate more pool space by simply
+          # connecting more sockets
+          (pool_size - @pool.length).times { @pool[_connect] = Mutex.new }
+
+        else
+
+          # remove from the pool by trying to remove available
+          # sockets over and over until they are gone.
+          #
+          # This has the effect of waiting for clients to be done
+          # with the socket, without hanging on any one mutex.
+          while @pool.length > pool_size do
+
+            # Go through and remove from the pool if unused.
+            @pool.each do |s, m|
+              if @pool.length > pool_size && m.try_lock
+                _disconnect(s)
+                @pool.delete(s)
+              end
+            end
+
+            # Since we're spinning, delay for a while
+            sleep(0.05)
+          end
+        end
+      end
     end
 
-    # Alias for close
-    alias :disconnect :close
+    # Close all persistent connections to the server.
+    def disconnect
+      persist(0)
+    end
 
-    # Is the client currently connected?
+    # Is this client maintaining any persistent connections?
+    #
+    # Returns true/false if the client is single-threaded,
+    # or the number of active connections if the client is multi-threaded
     def connected?
-      @m.synchronize{
-        _connected?
-      }
+
+      # If not threaded, simply check socket
+      @mutex.synchronize { return _connected?(@s) } unless @threaded
+
+      # if threaded, return pool length
+      @pool_mutex.synchronize { return (@pool.length) }
     end
 
+    # -------------------------------------------------------------------------
+    # Call handling
+    #
+
     # Call a method that is otherwise clobbered
     # by the client object, e.g.:
     #
     #   client.call(:dup) # return a copy of the server object
     #
-    def call(m, *args)
-      method_missing(m, *args)
+    def call(m, *args, &block)
+      method_missing(m, *args, &block)
     end
 
     # Calls RPC on the remote object.
     #
-    # You should not need to call this directly.
+    # You should not need to call this directly (though you are welcome to).
     #
     def method_missing(m, *args, &block)
 
+      # Records the server's return values.
       result      = nil
       success     = true
 
-      @m.synchronize{
-        already_connected = _connected?
-        if not already_connected
-          raise Errno::ECONNREFUSED, "Failed to connect" if not _connect
-        end
+      # Get a socket preferentially from the pool,
+      # and do the actual work
+      _get_socket() do |s, persist|
+
         # send method name and arity
-        _send([m, args, already_connected])
+        SocketProtocol::Stream.send(s, [m, args, block_given?, persist], @serialiser, @timeout)
 
-        # call with args
-        success, result = _recv
+        # Call with args
+        success, result = SocketProtocol::Stream.recv(s, @serialiser, @timeout)
         
-        # Then d/c
-        _disconnect if not already_connected
-      }
-     
-      # puts "[c] /calling #{m}..."
+        # Check if we should yield
+        while success == SocketProtocol::REQUEST_YIELD do
+          block_result = yield(*result)
+          SocketProtocol::Stream.send(s, block_result, @serialiser, @timeout)
+          success, result = SocketProtocol::Stream.recv(s, @serialiser, @timeout)
+        end
+
+      end
+
       # If it didn't succeed, treat the payload as an exception
-      raise result if not success 
+      raise RemoteException.new(result) unless success == SocketProtocol::REQUEST_SUCCESS
       return result
-
-    # rescue StandardError => e
-    #   $stderr.puts "-> #{e}, #{e.backtrace.join("--")}"
-    #   case e
-    #   when Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::ETIMEDOUT
-    #     c.close
-    #   else
-    #     raise e
-    #   end
     end
 
-  private
+    # Returns a proxy object that is all but indistinguishable
+    # from the remote object.
+    #
+    # This allows you to pass the object around whilst retaining control
+    # over the RPC client (i.e. calling persist/disconnect).
+    #
+    # The class returned extends BasicObject and is thus able to pass
+    # all calls through to the server.
+    #
+    def get_proxy
 
+      # Construct a new class as a subclass of RemoteObject
+      cls = Class.new(RemoteObject) do
 
-    # -------------------------------------------------------------------------
-    # Send/Receive
-    #
+        # Accept the originating client
+        def initialize(client)
+          @client = client
+        end
 
-    # Receive data from the server
-    def _recv
-      SocketProtocol::Stream.recv( @s, @serialiser, @timeout )
-    end
+        # And handle method_missing by calling the client
+        def method_missing(m, *args, &block)
+          @client.call(m, *args, &block)
+        end
+      end
 
-    # Send data to the server
-    def _send(obj)
-      SocketProtocol::Stream.send( @s, obj, @serialiser, @timeout )
+      # Return a new class linked to us
+      return cls.new(self)
     end
 
+
+  # ---------------------------------------------------------------------------
+  private
+
     # -------------------------------------------------------------------------
     # Socket management
     #
 
-    # Connect to the server
+    # Connect to the server and return a socket
     def _connect
       # Connect to the host
-      @s = Socket.tcp( @hostname, @port, nil, nil, :connect_timeout => @timeout )
-      
+      s = Socket.tcp(@hostname, @port, nil, nil, connect_timeout: @timeout)
+
       # Disable Nagle's algorithm
-      @s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-  
+      s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
       # if auth is required
-      if @password and @secret
-        salt      = SocketProtocol::Simple.recv( @s, @timeout )
-        challenge = Encryption.encrypt( @password, @secret, salt ) 
-        SocketProtocol::Simple.send( @s, challenge, @timeout )
-        if not @fast_auth
-          if SocketProtocol::Simple.recv( @s, @timeout ) != SocketProtocol::AUTH_SUCCESS
-            @s.close
-            raise AuthenticationError, "Authentication failed" 
+      if @password && @secret
+        salt      = SocketProtocol::Simple.recv(s, @timeout)
+        challenge = Encryption.encrypt(@password, @secret, salt)
+        SocketProtocol::Simple.send(s, challenge, @timeout)
+
+        # Check return if not @fast_auth
+        unless @fast_auth
+          unless SocketProtocol::Simple.recv(s, @timeout) == SocketProtocol::AUTH_SUCCESS
+            s.close
+            raise AuthenticationError, 'Authentication failed'
           end
         end
       end
 
       # Check and raise
-      return _connected?
+      return s
     end
 
-    # Disconnect from the server
-    def _disconnect
-      return if not _connected?
+    # Get a socket from the reusable pool if possible,
+    # else spawn a new one.
+    #
+    # Blocks if threading is off and the persistent socket
+    # is in use.
+    def _get_socket
+
+      # If not threaded, try using @s and block on @mutex
+      unless @threaded
+        # Try to load from pool
+        if @s
+          # Persistent connection
+          @mutex.synchronize do
+            
+            # Keepalive for pool sockets
+            unless _connected?(@s)
+              raise Errno::ECONNREFUSED, 'Failed to connect' unless (@s = _connect)
+            end
+
+            yield(@s, true) 
+          end
+        else
+          # On-demand connection
+          @mutex.synchronize { yield(_connect, false) }
+        end
+        return
+      end
+
+      # If threaded, try using the pool and use try_lock instead,
+      # then fall back to using a new connection
+
+      # Look through the pool to find a suitable socket
+      @pool.each do |s, m|
+
+        # If not threaded, block.
+        if s && m && m.try_lock
+          begin
+
+            # Keepalive for pool sockets
+            unless _connected?(s)
+              raise Errno::ECONNREFUSED, 'Failed to connect' unless (s = _connect)
+            end
+
+            # Increase count of active connections and yield
+            yield(s, true)
+          ensure
+            m.unlock
+          end
+          return
+        end
+      end
+
+      # Else use a temporary one...
+      s = _connect
+      yield(s, false)
+      _disconnect(s)
+    end
+
+    # Disconnect a socket from the server
+    def _disconnect(s)
+      return unless _connected?(s)
 
       # Then underlying socket
-      @s.close if @s and not @s.closed?
-      @s = nil
+      s.close if s && !s.closed?
     end
 
-    # Non-mutexed check for connectedness
-    def _connected?
-      @s and not @s.closed?
+    # Thread-unsafe check for connectedness
+    def _connected?(s)
+      s && !s.closed?
     end
 
   end
 
 end
-

data/lib/simplerpc/encryption.rb

@@ -15,30 +15,30 @@ module SimpleRPC
     CIPHER_STRENGTH = 256
 
     # Encrypt data
-    def self.encrypt( password, secret, salt )
+    def self.encrypt(password, secret, salt)
         # Encrypt with salted key
-        cipher         = OpenSSL::Cipher::AES.new( CIPHER_STRENGTH, :CBC )
+        cipher         = OpenSSL::Cipher::AES.new(CIPHER_STRENGTH, :CBC)
         cipher.encrypt
-        cipher.key     = salt_key( salt, secret )
+        cipher.key     = salt_key(salt, secret)
         return cipher.update(password) + cipher.final
-    rescue StandardError => e
+    rescue StandardError
       return nil  # Don't allow anyone to deliberately cause lockups
     end
 
     # Decrypt data
-    def self.decrypt( raw, secret, salt )
+    def self.decrypt(raw, secret, salt)
         # Decrypt raw input
-        decipher      = OpenSSL::Cipher::AES.new( CIPHER_STRENGTH, :CBC )
+        decipher      = OpenSSL::Cipher::AES.new(CIPHER_STRENGTH, :CBC)
         decipher.decrypt
-        decipher.key  = salt_key( salt, secret )
+        decipher.key  = salt_key(salt, secret)
         return decipher.update(raw) + decipher.final
-    rescue StandardError => e
+    rescue StandardError
       return nil  # Don't allow anyone to deliberately cause lockups
     end
 
     # Salt a key by simply adding the two
     # together
-    def self.salt_key( salt, key )
+    def self.salt_key(salt, key)
       return salt + key
     end
 

data/lib/simplerpc/server.rb

@@ -1,20 +1,41 @@
 
-
 require 'socket'               # Get sockets from stdlib
 require 'simplerpc/socket_protocol'
 
-module SimpleRPC 
+# rubocop:disable LineLength
+
+
 
+module SimpleRPC
+
+  # Thrown when #listen is called but the server
+  # is already listening on the port given
+  class AlreadyListeningError < Exception
+  end
 
   # SimpleRPC's server.  This wraps an object and exposes its methods to the network.
   #
   # i.e.:
-  #   
+  #
   #   require 'simplerpc/server'
+  #
+  #   # Expose the Array api on port 27045
   #   s = SimpleRPC::Server.new( ["thing", "thing2"], :port => 27045 )
+  #
+  #   # Listen in a thread so we can shut down later
   #   Thread.new(){ s.listen }
   #   sleep(10)
-  #   s.close     # Thread-safe
+  #
+  #   # Tell the server to exit cleanly
+  #   s.close
+  #
+  # == Thread Safety
+  #
+  # The server is thread-safe, and will not interrupt any clients when #close is called
+  # (instead it will wait for requests to finish, then shut down).
+  #
+  # If :threaded is set to true, the server will be able to make many simultaneous calls
+  # to the object being proxied.
   #
   # == Controlling a Server
   #
@@ -24,7 +45,7 @@ module SimpleRPC
   #
   # 1. The current client requests will end
   # 2. The socket will close
-  # 3. #listen and #close will return (almost) simultaneously 
+  # 3. #listen and #close will return (almost) simultaneously
   #
   # == Serialisation Formats
   #
@@ -34,7 +55,7 @@ module SimpleRPC
   # The serialiser also supports MessagePack (the msgpack gem), and this yields a small
   # performance increase at the expense of generality (restrictions on data type).
   #
-  # Note that JSON and YAML, though they support reading and writing to sockets, do not 
+  # Note that JSON and YAML, though they support reading and writing to sockets, do not
   # properly terminate their reads and cause the system to hang.  These methods are
   # both slow and limited by comparison anyway, and algorithms needed to support their
   # use require relatively large memory usage.  They may be supported in later versions.
@@ -47,7 +68,7 @@ module SimpleRPC
   # speed) so the results of using mismatched configurations are undefined.
   #
   # The auth process is simple and not particularly secure, but is designed to deter casual
-  # connections and attacks.  It uses a password that is sent encrypted against a salt sent 
+  # connections and attacks.  It uses a password that is sent encrypted against a salt sent
   # by the server to prevent replay attacks.  If you want more reliable security, use an SSH tunnel.
   #
   # The performance impact of auth is small, and takes about the same time as a simple
@@ -58,24 +79,24 @@ module SimpleRPC
     attr_reader :hostname, :port, :obj, :threaded
     attr_accessor :verbose_errors, :serialiser, :timeout, :fast_auth
     attr_writer :password, :secret
-    
+
     # Create a new server for a given proxy object.
     #
-    # The single required parameter, obj, is an object you wish to expose to the 
+    # The single required parameter, obj, is an object you wish to expose to the
     # network.  This is the API that will respond to RPCs.
     #
     # Takes an option hash with options:
     #
     # [:port] The port on which to listen, or 0 for the OS to set it
     # [:hostname] The hostname of the interface to listen on (omit for all interfaces)
-    # [:serialiser] A class supporting #load(IO) and #dump(obj, IO) for serialisation.  
+    # [:serialiser] A class supporting #load(IO) and #dump(obj, IO) for serialisation.
     #               Defaults to Marshal.  I recommend using MessagePack if this is not
     #               fast enough.  Note that JSON/YAML do not work as they don't send
     #               terminating characters over the socket.
     # [:verbose_errors] Report all socket errors from clients (by default these will be quashed).
     # [:timeout] Socket timeout in seconds.  Default is infinite (nil)
     # [:threaded] Accept more than one client at once?  Note that proxy object should be thread-safe for this
-    #             Default is single-threaded mode.
+    #             Default is on.
     # [:password] The password clients need to connect
     # [:secret] The encryption key used during password authentication.  Should be some long random string.
     # [:salt_size] The size of the string used as a nonce during password auth.  Defaults to 10 chars
@@ -102,7 +123,7 @@ module SimpleRPC
       @timeout              = opts[:timeout]
 
       # Auth
-      if opts[:password] and opts[:secret] then
+      if opts[:password] && opts[:secret]
         require 'simplerpc/encryption'
         @password   = opts[:password]
         @secret     = opts[:secret]
@@ -110,87 +131,92 @@ module SimpleRPC
       end
 
       # Threaded or not?
-      @threaded             = (opts[:threaded] == true)
-      if(@threaded)
+      @threaded             = !(opts[:threaded] == false)
+      if @threaded
         @clients            = {}
-        @m                  = Mutex.new
+        @mc                 = Mutex.new # Client list mutex
       end
+
+      # Listener mutex
+      @ml                   = Mutex.new
     end
 
     # Start listening forever.
     #
     # Use threads and .close to stop the server.
     #
+    # Throws AlreadyListeningError when the server is already
+    # busy listening for connections
     def listen
+      raise 'Server is already listening' unless @ml.try_lock
+
       # Listen on one interface only if hostname given
-      create_server_socket if not @s or @s.closed?
+      s = create_server_socket
 
       # Handle clients
-      loop{
-
-        begin
-          # Accept in an interruptable manner
-          if( c = interruptable_accept )
-            if @threaded
-    
-              # Create the thread
-              id = rand.hash
-              thread = Thread.new(id, @m, c){|id, m, c|  
-                handle_client(c)
-
-                m.synchronize{
-                  @clients.delete(id)
-                }
-              }
-
-              # Add to the client list
-              @m.synchronize{
-                @clients[id] = thread
-              }
-            else
-              # Handle client 
-              handle_client(c)
+      loop do
+      
+        # Accept in an interruptable manner
+        if (c = interruptable_accept(s))
+          # Threaded
+          if @threaded
+
+            # Create the id
+            id = rand.hash
+
+            # Add to the client list
+            @mc.synchronize do
+              @clients[id] = Thread.new() do
+                # puts "[#{@clients.length+1}->#{id}"
+                begin
+                  handle_client(c)
+                ensure
+                  # Remove self from list
+                  @mc.synchronize { @clients.delete(id) }
+                  # puts "[#{@clients.length}<-#{id}"
+                end
+              end
+              @clients[id].abort_on_exception = true
             end
+
+          # Single-threaded
+          else
+            # Handle client
+            handle_client(c)
           end
-        rescue StandardError => e
-          raise e if @verbose_errors
         end
 
         break if @close
-      }
+      end
 
       # Wait for threads to end
-      if @threaded then
-        @clients.each{|id, thread|
-          thread.join
-        }
-      end
+      @clients.each {|id, thread| thread.join } if @threaded
 
       # Close socket
-      close_server_sockets
-
-      # Finally, say we've closed
-      @close = false if @close
+      @close = false if @close  # say we've closed
+      @ml.unlock
     end
 
-    # Return the number of active clients.
-    def active_clients
-      @m.synchronize{
-        @clients.length
-      }
+    # Return the number of active client threads.
+    #
+    # Returns 0 if :threaded is set to false.
+    def active_client_threads
+      # If threaded return a count from the clients list
+      return @mc.synchronize { @clients.length } if @threaded
+
+      # Else return 0 if not threaded
+      return 0
     end
 
     # Close the server object nicely,
     # waiting on threads if necessary
     def close
       # Ask the loop to close
-      @close = true
       @close_in.putc 'x' # Tell select to close
 
-      # Wait for loop to end 
-      while(@close)
-        sleep(0.1)
-      end
+      # Wait for loop to end
+      @ml.lock
+      @ml.unlock
     end
 
   private
@@ -198,23 +224,25 @@ module SimpleRPC
     # -------------------------------------------------------------------------
     # Client Management
     #
-  
-    # Accept with the ability for other 
+
+    # Accept with the ability for other
     # threads to call close
-    def interruptable_accept
-      c = IO.select([@s, @close_out], nil, nil)
-   
+    def interruptable_accept(s)
+      c = IO.select([s, @close_out], nil, nil)
+
       # puts "--> #{c}"
 
-      return nil if not c
-      if(c[0][0] == @close_out)  
+      return nil unless c
+      if c[0][0] == @close_out
         # @close is set, so consume from socket
         # and return nil
         @close_out.getc
-        return nil 
+        @close = true
+        s.close   # close server socket
+        return nil
       end
-      return @s.accept if( not @close and c )
-    rescue IOError => e
+      return s.accept if !@close && c
+    rescue IOError
       # cover 'closed stream' errors
       return nil
     end
@@ -225,108 +253,102 @@ module SimpleRPC
       c.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
       # Encrypted password auth
-      if @password and @secret
+      if @password && @secret
         # Send challenge
         # XXX: this is notably not crytographically random,
         #      but it's better than nothing against replay attacks
-        salt = Random.new.bytes( @salt_size )
-        SocketProtocol::Simple.send( c, salt, @timeout )
+        salt = Random.new.bytes(@salt_size)
+        SocketProtocol::Simple.send(c, salt, @timeout)
 
         # Receive encrypted challenge
-        raw = SocketProtocol::Simple.recv( c, @timeout )
+        raw = SocketProtocol::Simple.recv(c, @timeout)
 
         # D/c if failed
-        if Encryption.decrypt( raw, @secret, salt) != @password
-          SocketProtocol::Simple.send( c, SocketProtocol::AUTH_FAIL, @timeout )   if not @fast_auth
-          c.close
+        unless Encryption.decrypt(raw, @secret, salt) == @password
+          SocketProtocol::Simple.send(c, SocketProtocol::AUTH_FAIL, @timeout) unless @fast_auth
           return
         end
-        SocketProtocol::Simple.send( c, SocketProtocol::AUTH_SUCCESS, @timeout )     if not @fast_auth
+        SocketProtocol::Simple.send(c, SocketProtocol::AUTH_SUCCESS, @timeout) unless @fast_auth
       end
 
       # Handle requests
       persist = true
-      while(not @close and persist) do
+      while !@close && persist do
 
-        m, args, persist = recv(c)
-        # puts "Method: #{m}, args: #{args}, persist: #{persist}"
+        # Note, when clients d/c this throws EOFError
+        m, args, remote_block_given, persist = SocketProtocol::Stream.recv(c, @serialiser, @timeout)
+        # puts "Method: #{m}, args: #{args}, block?: #{remote_block_given}, persist: #{persist}"
 
-        if(m and args) then
+        if m && args
 
           # Record success status
           result    = nil
-          success   = true
+          success   = SocketProtocol::REQUEST_SUCCESS
 
           # Try to make the call, catching exceptions
           begin
-            result  = @obj.send(m, *args)
+
+            if remote_block_given
+              # Proxy with a block that sends back to the client
+              result  = @obj.send(m, *args) do |*yield_args|
+                SocketProtocol::Stream.send(c, [SocketProtocol::REQUEST_YIELD, yield_args], @serialiser, @timeout)
+                SocketProtocol::Stream.recv(c, @serialiser, @timeout)
+              end
+
+            else
+              # Proxy without block for correct exceptions
+              result  = @obj.send(m, *args)
+            end
+
           rescue StandardError => se
             result  = se
-            success = false
+            success = SocketProtocol::REQUEST_FAIL
           end
 
           # Send over the result
           # puts "[s] sending result..."
-          send(c, [success, result] )
+          SocketProtocol::Stream.send(c, [success, result], @serialiser, @timeout)
         else
           persist = false
         end
 
       end
-        
-      # Close
-      c.close
+
     rescue StandardError => e
       case e
-      when Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::ETIMEDOUT
-        c.close
+      when EOFError
+        return
+      when Errno::EPIPE, Errno::ECONNRESET,
+           Errno::ECONNABORTED, Errno::ETIMEDOUT
+        raise e if @verbose_errors
       else
-        raise e 
+        raise e if @verbose_errors
       end
-    end
-
-    # -------------------------------------------------------------------------
-    # Send/Receive
-    # 
-
-    # Receive data from a client
-    def recv(c)
-      SocketProtocol::Stream.recv( c, @serialiser, @timeout )
-    end
-
-    # Send data to a client
-    def send(c, obj)
-      SocketProtocol::Stream.send( c, obj, @serialiser, @timeout )
+    ensure
+      # Always ensure we close the socket
+      c.close
     end
 
     # -------------------------------------------------------------------------
     # Socket Management
     #
 
-    # Creates a new socket with the given timeout
+    # Creates a new socket
+    # and returns it
     def create_server_socket
-      if @hostname 
-        @s = TCPServer.open( @hostname, @port )
+      if @hostname
+        s = TCPServer.open(@hostname, @port)
       else
-        @s = TCPServer.open( @port )
+        s = TCPServer.open(@port)
       end
-      @port = @s.addr[1]
-
-      @s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
-    end
+      @port = s.addr[1]
 
-    # Close the server socket
-    def close_server_sockets
-      return if not @s 
+      s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
 
-      # Close underlying socket
-      @s.close    if @s and not @s.closed?
-      @s = nil
+      return s
     end
 
-
   end
 
-
 end
 

data/lib/simplerpc/socket_protocol.rb

@@ -2,7 +2,6 @@
 
 module SimpleRPC
 
-
   # SocketProtocol defines common low-level aspects of data transfer
   # between client and server.
   #
@@ -17,6 +16,15 @@ module SimpleRPC
     # Sent when auth fails
     AUTH_FAIL    = 'F'
 
+    # The request succeeded
+    REQUEST_SUCCESS = 0
+
+    # The request failed and threw something
+    REQUEST_FAIL    = 1
+
+    # The request is yielding data to a block
+    REQUEST_YIELD   = 2
+
     # Send objects by streaming them through a socket using
     # a serialiser such as Marshal.
     #
@@ -30,20 +38,19 @@ module SimpleRPC
     module Stream
 
       # Send using a serialiser writing through the socket
-      def self.send( s, obj, serialiser, timeout=nil )
-        raise Errno::ETIMEDOUT if not IO.select([], [s], [], timeout)
-        return serialiser.dump( obj, s )
+      def self.send(s, obj, serialiser, timeout = nil)
+        raise Errno::ETIMEDOUT unless IO.select([], [s], [], timeout)
+        return serialiser.dump(obj, s)
       end
 
       # Recieve using a serialiser reading from the socket
-      def self.recv( s, serialiser, timeout=nil )
-        raise Errno::ETIMEDOUT if not IO.select([s], [], [], timeout)
-        return serialiser.load( s )
+      def self.recv(s, serialiser, timeout = nil)
+        raise Errno::ETIMEDOUT unless IO.select([s], [], [], timeout)
+        return serialiser.load(s)
       end
 
     end
 
-
     # Sends string buffers back and forth using a simple protocol.
     # 
     # This method is significantly slower, but significantly more secure,
@@ -52,38 +59,38 @@ module SimpleRPC
     module Simple
 
       # Send a buffer
-      def self.send( s, buf, timeout=nil )
+      def self.send(s, buf, timeout = nil)
           # Dump into buffer
           buflen = buf.length
 
           # Send buffer length
-          raise Errno::ETIMEDOUT if not IO.select([], [s], [], timeout)
+          raise Errno::ETIMEDOUT unless IO.select([], [s], [], timeout)
           s.puts(buflen)
 
           # Send buffer
           sent = 0
-          while(sent < buflen and (x = IO.select([], [s], [], timeout))) do
-            sent += s.write( buf[sent..-1] )
+          while sent < buflen && (x = IO.select([], [s], [], timeout)) do
+            sent += s.write(buf[sent..-1])
           end
-          raise Errno::ETIMEDOUT if not x
+          raise Errno::ETIMEDOUT unless x
 
       end
 
       # Receive a buffer
-      def self.recv( s, timeout=nil )
-          raise Errno::ETIMEDOUT if not IO.select([s], [], [], timeout)
+      def self.recv(s, timeout = nil)
+          raise Errno::ETIMEDOUT unless IO.select([s], [], [], timeout)
           buflen = s.gets.to_s.chomp.to_i
 
           return nil if buflen <= 0
 
-          buf = ""
+          buf = ''
           recieved = 0
-          while( recieved < buflen and (x = IO.select([s], [], [], timeout)) ) do
-            str = s.read( buflen - recieved )
+          while recieved < buflen && (x = IO.select([s], [], [], timeout)) do
+            str = s.read(buflen - recieved)
             buf += str
             recieved += str.length
           end
-          raise Errno::ETIMEDOUT if not x
+          raise Errno::ETIMEDOUT unless x
 
           return buf
       end

data/lib/simplerpc.rb

@@ -1,7 +1,6 @@
 
 require 'simplerpc/server'
 require 'simplerpc/client'
-require 'simplerpc/serialiser'
 
 # SimpleRPC is a very simple RPC library for ruby, designed to be as fast as possible whilst still
 # retaining a simple API.
@@ -16,6 +15,6 @@ require 'simplerpc/serialiser'
 # and including it includes all other project files
 module SimpleRPC
 
-  VERSION = "0.2.0b"
+  VERSION = '0.2.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplerpc
 version: !ruby/object:Gem::Version
-  version: 0.2.0c
+  version: 0.2.0
 platform: ruby
 authors:
 - Stephen Wattam
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-28 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies: []
 description: A very simple and fast RPC library
 email: stephenwattam@gmail.com
@@ -37,9 +37,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.0