simplerpc 0.2.4 → 0.3.0c

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc9653218ecb394370d5c9a4a9ddc57c496b7124
-  data.tar.gz: f6c2cbc647bc3573dfb471c2c032e032245369fb
+  metadata.gz: 727d91ba2fea5bec49b44ad808dd37eef9d6f800
+  data.tar.gz: 70950f3bf04baa1f281926e748554dee0623edb7
 SHA512:
-  metadata.gz: 071d0a5ce8fc194496c4253dc8ec2d4323e00ea2b66af41e8368639b84fab5545eabe76f3bbe36ec338b3d3a589f31bc874cb130e1f661e7ae61e19865b7ccfd
-  data.tar.gz: 27c9bdff6148aa3849a6d3707aef01351373c4f76b900c33194ab9a447c609479facb45d2e988ba589fc840248622676dd5aba487b1ff67d6e61f9343721abe2
+  metadata.gz: e3894eeff293db5d898c4ae87d7d83f840ee9e18e0356cb77af5ce9d6e17bcf70aa5b2d672d80d05e30e071d97b32fe66f7bb7c8ed40db3584de247e9e4fe29a
+  data.tar.gz: 3ba4862e358f939cd462506492dfeaf27a5589a49bba8c0af3f7ecaccc494015d2f72a474dcf8dbb8e620c9847526ee4344fe152d95357ce0c56a72f49527839

data/lib/simplerpc.rb

@@ -1,7 +1,4 @@
 
-require 'simplerpc/server'
-require 'simplerpc/client'
-
 # SimpleRPC is a very simple RPC library for ruby, designed to be as fast as possible whilst still
 # retaining a simple API.
 #
@@ -14,7 +11,8 @@ require 'simplerpc/client'
 # This module simply contains version information,
 # and including it includes all other project files
 module SimpleRPC
-
-  VERSION = '0.2.3'
-
+  require_relative 'simplerpc/exceptions'
+  require_relative 'simplerpc/server'
+  require_relative 'simplerpc/client'
+  require_relative 'simplerpc/version'
 end

data/lib/simplerpc/client.rb

@@ -1,5 +1,6 @@
 require 'socket'
 require 'simplerpc/socket_protocol'
+require 'simplerpc/exceptions'
 
 # rubocop:disable LineLength
 
@@ -11,30 +12,6 @@ module SimpleRPC
   class AuthenticationError < StandardError
   end
 
-  # Thrown when the server raises an exception.
-  #
-  # The message is set to the server's exception class.
-  class RemoteException < Exception
-    
-    attr_reader :remote_exception
-
-    def initialize(exception)
-      super(exception)
-      @remote_exception = exception
-    end
-
-    # Return the backtrace from the original (remote) 
-    # exception
-    def backtrace
-      @remote_exception.backtrace
-    end
-
-    # Return a string representing the remote exception
-    def to_s
-      @remote_exception.to_s
-    end
-  end
-
   # The superclass of a proxy object
   class RemoteObject < BasicObject
   end
@@ -97,7 +74,8 @@ module SimpleRPC
   #
   # == Exceptions
   #
-  # Remote exceptions fired by the server during a call are wrapped in RemoteException.
+  # Remote exceptions fired by the server during a call are returned as RemoteExceptions,
+  # and have the message and backtrace set as if you are on the remote server.
   #
   # 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
@@ -160,8 +138,8 @@ module SimpleRPC
   #
   class Client
 
-    attr_reader     :hostname,    :port,    :threaded
-    attr_accessor   :serialiser,  :timeout, :fast_auth
+    attr_reader     :hostname,    :port,    :threaded, :timeout
+    attr_accessor   :serialiser,  :fast_auth
     attr_writer     :password,    :secret
 
     # Create a new client for the network.
@@ -187,7 +165,8 @@ module SimpleRPC
       @hostname     = opts[:hostname]   || '127.0.0.1'
       @port         = opts[:port]
       raise 'Port required' unless @port
-      @timeout      = opts[:timeout]
+      timeout       = opts[:timeout]
+
 
       # Support multiple connections at once?
       @threaded     = !(opts[:threaded] == false)
@@ -216,6 +195,20 @@ module SimpleRPC
       end
     end
 
+  
+    # Set the timeout on all socket operations,
+    # including connection
+    def timeout=(timeout)
+      @timeout      = timeout
+      @socket_timeout = nil
+
+      if @timeout.to_f > 0
+        secs            = @timeout.floor
+        usecs           = (@timeout - secs).floor * 1_000_000
+        @socket_timeout = [secs, usecs].pack("l_2")
+      end
+    end
+
     # Connect to the remote server and return two things:
     #
     # * A proxy object for communicating with the server
@@ -296,6 +289,9 @@ module SimpleRPC
           end
         end
       end
+    rescue EOFError, Errno::ECONNRESET, Errno::ETIMEDOUT, 
+           Errno::ECONNREFUSED, Errno::ECONNABORTED, Errno::EPIPE => e
+      raise ConnectionError.new(e)
     end
 
     # Close all persistent connections to the server.
@@ -344,23 +340,28 @@ module SimpleRPC
       _get_socket() do |s, persist|
 
         # send method name and arity
-        SocketProtocol::Stream.send(s, [m, args, block_given?, persist], @serialiser, @timeout)
+        SocketProtocol::Stream.send(s, [m, args, block_given?, persist], @serialiser)
 
         # Call with args
-        success, result = SocketProtocol::Stream.recv(s, @serialiser, @timeout)
+        success, result = SocketProtocol::Stream.recv(s, @serialiser)
         
         # 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)
+          SocketProtocol::Stream.send(s, block_result, @serialiser)
+          success, result = SocketProtocol::Stream.recv(s, @serialiser)
         end
 
       end
 
       # If it didn't succeed, treat the payload as an exception
-      raise RemoteException.new(result) unless success == SocketProtocol::REQUEST_SUCCESS
+      raise result unless success == SocketProtocol::REQUEST_SUCCESS
       return result
+    rescue EOFError, Errno::ECONNRESET, Errno::ETIMEDOUT, 
+           Errno::ECONNREFUSED, Errno::ECONNABORTED, Errno::EPIPE => e
+      raise ConnectionError.new(e)
+    rescue StandardError => e
+      raise FormatError.new(e)
     end
 
     # Returns a proxy object that is all but indistinguishable
@@ -403,21 +404,32 @@ module SimpleRPC
     # 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)
+      s = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
 
       # Disable Nagle's algorithm
       s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
+      # Set timeout directly on socket
+      if @socket_timeout
+        s.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, @socket_timeout)
+        s.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, @socket_timeout)
+      end
+
+      
+      s.connect( Socket.pack_sockaddr_in( @port, @hostname.to_s ) )
+
+
       # if auth is required
       if @password && @secret
-        salt      = SocketProtocol::Simple.recv(s, @timeout)
+        salt      = SocketProtocol::Simple.recv(s)
         challenge = Encryption.encrypt(@password, @secret, salt)
 
-        SocketProtocol::Simple.send(s, challenge, @timeout)
+        SocketProtocol::Simple.send(s, challenge)
 
         # Check return if not @fast_auth
         unless @fast_auth
-          unless SocketProtocol::Simple.recv(s, @timeout) == SocketProtocol::AUTH_SUCCESS
+          unless SocketProtocol::Simple.recv(s) == SocketProtocol::AUTH_SUCCESS
             s.close
             raise AuthenticationError, 'Authentication failed'
           end
@@ -501,4 +513,10 @@ module SimpleRPC
 
   end
 
+
+  class FastClient
+    
+  end
+
+
 end

data/lib/simplerpc/exceptions.rb

@@ -0,0 +1,36 @@
+
+
+
+
+module SimpleRPC
+
+  # Superclass of all RPC-related exceptions
+  class RPCError < Exception
+   
+    attr_reader :cause
+
+    def initialize(exception)
+      super("#{exception.class}: #{exception}")
+      set_backtrace(exception.backtrace)
+    end
+
+  end
+
+
+  # Called when the serialiser fails to deserialise something
+  class FormatError < RPCError
+  end
+
+  # Called when the connection fails
+  class ConnectionError < RPCError
+  end
+
+  # Thrown when the server raises an exception.
+  #
+  # The message is set to the server's exception class.
+  class RemoteException < RPCError
+  end
+
+end
+
+

data/lib/simplerpc/server.rb

@@ -1,6 +1,7 @@
 
 require 'socket'               # Get sockets from stdlib
 require 'simplerpc/socket_protocol'
+require 'simplerpc/exceptions'
 
 # rubocop:disable LineLength
 
@@ -76,8 +77,8 @@ module SimpleRPC
   #
   class Server
 
-    attr_reader :hostname, :port, :obj, :threaded
-    attr_accessor :verbose_errors, :serialiser, :timeout, :fast_auth
+    attr_reader :hostname, :port, :obj, :threaded, :timeout
+    attr_accessor :verbose_errors, :serialiser, :fast_auth
     attr_writer :password, :secret
 
     # Create a new server for a given proxy object.
@@ -121,7 +122,7 @@ module SimpleRPC
       @close_in, @close_out = UNIXSocket.pair
 
       # Connect/receive timeouts
-      @timeout              = opts[:timeout]
+      timeout               = opts[:timeout]
 
       # Auth
       if opts[:password] && opts[:secret]
@@ -143,6 +144,21 @@ module SimpleRPC
       @ml                   = Mutex.new
     end
 
+ 
+    # Set the timeout on all socket operations,
+    # including connection
+    def timeout=(timeout)
+      @timeout      = timeout
+      @socket_timeout = nil
+
+      if @timeout.to_f > 0
+        secs            = @timeout.floor
+        usecs           = (@timeout - secs).floor * 1_000_000
+        @socket_timeout = [secs, usecs].pack("l_2")
+      end
+    end
+
+
     # Start listening forever.
     #
     # Use threads and .close to stop the server.
@@ -160,6 +176,13 @@ module SimpleRPC
 
         # Accept in an interruptable manner
         if (c = interruptable_accept(s))
+
+          # Set timeout directly on socket
+          if @socket_timeout
+            c.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, @socket_timeout)
+            c.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, @socket_timeout)
+          end
+
           # Threaded
           if @threaded
 
@@ -196,6 +219,7 @@ module SimpleRPC
 
       # Close socket
       @close = false if @close  # say we've closed
+    ensure
       @ml.unlock
     end
 
@@ -204,7 +228,7 @@ module SimpleRPC
     # 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
+      return @clients.length if @threaded
 
       # Else return 0 if not threaded
       return 0
@@ -212,13 +236,25 @@ module SimpleRPC
 
     # Close the server object nicely,
     # waiting on threads if necessary
-    def close
+    def close(timeout = false)
+      # Return immediately if the server isn't listening
+      return unless @ml.locked?
+      
       # Ask the loop to close
       @close_in.putc 'x' # Tell select to close
 
+      
       # Wait for loop to end
-      @ml.lock
-      @ml.unlock
+      elapsed_time = 0
+      while @ml.locked? do
+        sleep(0.05)
+        elapsed_time += 0.05
+
+        # If a timeout is given, try killing threads at this point
+        if timeout && elapsed_time > timeout
+          @clients.each {|id, thread| thread.kill() }
+        end
+      end
     end
 
   private
@@ -232,8 +268,6 @@ module SimpleRPC
     def interruptable_accept(s)
       c = IO.select([s, @close_out], nil, nil)
 
-      # puts "--> #{c}"
-
       return nil unless c
       if c[0][0] == @close_out
         # @close is set, so consume from socket
@@ -244,6 +278,7 @@ module SimpleRPC
         return nil
       end
       return s.accept if !@close && c
+      return nil
     rescue IOError
       # cover 'closed stream' errors
       return nil
@@ -266,17 +301,17 @@ module SimpleRPC
           rescue NotImplementedError
             salt = Random.new.bytes(@salt_size)
           end
-          SocketProtocol::Simple.send(c, salt, @timeout)
+          SocketProtocol::Simple.send(c, salt)
 
           # Receive encrypted challenge
-          raw = SocketProtocol::Simple.recv(c, @timeout)
+          raw = SocketProtocol::Simple.recv(c)
 
           # D/c if failed
           unless Encryption.decrypt(raw, @secret, salt) == @password
-            SocketProtocol::Simple.send(c, SocketProtocol::AUTH_FAIL, @timeout) unless @fast_auth
+            SocketProtocol::Simple.send(c, SocketProtocol::AUTH_FAIL) unless @fast_auth
             return
           end
-          SocketProtocol::Simple.send(c, SocketProtocol::AUTH_SUCCESS, @timeout) unless @fast_auth
+          SocketProtocol::Simple.send(c, SocketProtocol::AUTH_SUCCESS) unless @fast_auth
         rescue
           # Auth failure is silent for the server
           return
@@ -288,7 +323,7 @@ module SimpleRPC
       while !@close && persist do
 
         # Note, when clients d/c this throws EOFError
-        m, args, remote_block_given, persist = SocketProtocol::Stream.recv(c, @serialiser, @timeout)
+        m, args, remote_block_given, persist = SocketProtocol::Stream.recv(c, @serialiser)
         # puts "Method: #{m}, args: #{args}, block?: #{remote_block_given}, persist: #{persist}"
 
         if m && args
@@ -303,8 +338,8 @@ module SimpleRPC
             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)
+                SocketProtocol::Stream.send(c, [SocketProtocol::REQUEST_YIELD, yield_args], @serialiser)
+                SocketProtocol::Stream.recv(c, @serialiser)
               end
 
             else
@@ -313,13 +348,15 @@ module SimpleRPC
             end
 
           rescue StandardError => se
-            result  = se
+            # Ensure the passed exception has no class hierarchy from
+            # this object space (which would not work on the client)
+            result  = RemoteException.new(se)
             success = SocketProtocol::REQUEST_FAIL
           end
 
           # Send over the result
           # puts "[s] sending result..."
-          SocketProtocol::Stream.send(c, [success, result], @serialiser, @timeout)
+          SocketProtocol::Stream.send(c, [success, result], @serialiser)
         else
           persist = false
         end

data/lib/simplerpc/socket_protocol.rb

@@ -38,14 +38,12 @@ module SimpleRPC
     module Stream
 
       # Send using a serialiser writing through the socket
-      def self.send(s, obj, serialiser, timeout = nil)
-        raise Errno::ETIMEDOUT unless IO.select([], [s], [], timeout)
+      def self.send(s, obj, serialiser)
         return serialiser.dump(obj, s)
       end
 
       # Recieve using a serialiser reading from the socket
-      def self.recv(s, serialiser, timeout = nil)
-        raise Errno::ETIMEDOUT unless IO.select([s], [], [], timeout)
+      def self.recv(s, serialiser)
         return serialiser.load(s)
       end
 
@@ -59,40 +57,38 @@ module SimpleRPC
     module Simple
 
       # Send a buffer
-      def self.send(s, buf, timeout = nil)
+      def self.send(s, buf)
           # Dump into buffer
           buflen = buf.length
 
           # Send buffer length
-          raise Errno::ETIMEDOUT unless IO.select([], [s], [], timeout)
           s.puts(buflen)
 
           # Send buffer
           sent = 0
-          while sent < buflen && (x = IO.select([], [s], [], timeout)) do
+          while sent < buflen do 
             sent += s.write(buf[sent..-1])
           end
-          raise Errno::ETIMEDOUT unless x
+          # raise Errno::ETIMEDOUT unless x
 
       end
 
       # Receive a buffer
-      def self.recv(s, timeout = nil)
-          raise Errno::ETIMEDOUT unless IO.select([s], [], [], timeout)
+      def self.recv(s)
           buflen = s.gets.to_s.chomp.to_i
 
           return nil if buflen <= 0
 
           buf = ''
           recieved = 0
-          while recieved < buflen && (x = IO.select([s], [], [], timeout)) do
+          while recieved < buflen do
             str = s.read(buflen - recieved)
             buf += str
             recieved += str.length
           end
-          raise Errno::ETIMEDOUT unless x
 
           return buf
+
       end
 
     end

data/lib/simplerpc/version.rb

@@ -0,0 +1,5 @@
+module SimpleRPC
+
+  VERSION = '0.3.0c'
+
+end

metadata

@@ -1,48 +1,50 @@
 --- !ruby/object:Gem::Specification
 name: simplerpc
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0c
 platform: ruby
 authors:
 - Stephen Wattam
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-20 00:00:00.000000000 Z
+date: 2016-04-25 00:00:00.000000000 Z
 dependencies: []
 description: A very simple and fast RPC library
-email: stephenwattam@gmail.com
+email: steve@stephenwattam.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- "./lib/simplerpc.rb"
+- LICENSE
+- lib/simplerpc/client.rb
 - lib/simplerpc/encryption.rb
+- lib/simplerpc/exceptions.rb
 - lib/simplerpc/server.rb
 - lib/simplerpc/socket_protocol.rb
-- lib/simplerpc/client.rb
-- ./lib/simplerpc.rb
-- LICENSE
+- lib/simplerpc/version.rb
 homepage: http://stephenwattam.com/projects/simplerpc
 licenses:
 - Beerware
 metadata: {}
-post_install_message: Thanks for installing SimpleRPC!
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Simple RPC library