simplerpc 0.1.0c

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ff810496dda2e7d4adb2c9a423bc13784986e2c3
+  data.tar.gz: 84a9a286a976103d6912999ebbfdbcb1fcb11a8d
+SHA512:
+  metadata.gz: 6cc60d3b1eb680a8c04aa94b21d7da6cabe3efcfdc367a145e66d60d7bb612cd2da29e9982cd29aa484c608e649f96adb0a66067d4ab65cbade0f57d0953ba2c
+  data.tar.gz: 88b99defcca647ee221abb9901fc37eb391b60455f17ed1629df9400398f934323291ff6a5911d9d7b7cd8ba74a9f9752008814e4ef01bb4563c2082e4008a84

data/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) Stephen Wattam 2013, <stephenwattam.com>.
+
+As long as you retain this license you can do whatever you like with this code.  
+If we meet some day, and you think this stuff was worth it, you can buy me a beer.

data/lib/simplerpc/client.rb

@@ -0,0 +1,124 @@
+require 'socket'      # Sockets are in standard library
+require 'simplerpc/serialiser'
+require 'simplerpc/socket_protocol'
+
+module SimpleRPC 
+
+  # The SimpleRPC client connects to a server, either persistently on on-demand, and makes
+  # calls to its proxy object.
+  #
+  # Once created, you should be able to interact with the client as if it were the remote
+  # object.
+  #
+  class Client
+
+    # Create a new client for the network
+    # 
+    # hostname:: The hostname of the server
+    # port:: The port to connect to
+    # serialiser:: An object supporting load/dump for serialising objects.  Defaults to
+    #              SimpleRPC::Serialiser
+    # timeout:: The socket timeout.  Throws Timeout::TimeoutErrors when exceeded.  Set
+    #           to nil to disable.
+    def initialize(hostname, port, serialiser=Serialiser.new, timeout=nil)
+      @hostname     = hostname
+      @port         = port
+      @serialiser   = serialiser
+      @timeout      = timeout
+
+      @m = Mutex.new
+    end
+
+    # Connect to the server,
+    # or do nothing if already connected
+    def connect
+      @m.synchronize{
+        _connect
+      }
+    end
+
+    # Disconnect from the server
+    # or do nothing if already disconnected
+    def close
+      @m.synchronize{
+        _disconnect
+      }
+    end
+
+    # Alias for close
+    alias :disconnect :close
+
+    # Is the client currently connected?
+    def connected?
+      @m.synchronize{
+        not @s == nil
+      }
+    end
+
+    # Call a method that is otherwise clobbered
+    # by the client object
+    def call(m, *args)
+      method_missing(m, *args)
+    end
+
+    # Calls RPC on the remote object
+    def method_missing(m, *args, &block)
+      valid_call  = false
+      result      = nil
+
+      @m.synchronize{
+        already_connected = (not (@s == nil))
+        _connect if not already_connected
+        # send method name and arity
+        # #puts "c: METHOD: #{m}. ARITY: #{args.length}"
+        _send([m, args.length])
+
+        # receive yey/ney
+        valid_call = _recv
+
+        #puts "=--> #{valid_call}"
+
+        # call with args
+        if valid_call then
+          _send( args )
+          result = _recv
+        end
+        
+        # Then d/c
+        _disconnect if not already_connected
+      }
+     
+      # If the call wasn't valid, call super
+      if not valid_call then
+        result = super
+      end
+
+      return result
+    end
+
+  private
+    # Connect to the server
+    def _connect
+      @s = TCPSocket.open( @hostname, @port)
+    end
+
+    # Receive data from the server
+    def _recv
+      @serialiser.load( SocketProtocol::recv(@s, @timeout) )
+    end
+
+    # Send data to the server
+    def _send(obj)
+      SocketProtocol::send(@s, @serialiser.dump(obj), @timeout)
+    end
+
+    # Disconnect from the server
+    def _disconnect
+      return if not @s
+      @s.close
+      @s = nil
+    end
+  end
+
+end
+

data/lib/simplerpc/serialiser.rb

@@ -0,0 +1,67 @@
+
+module SimpleRPC 
+
+  # This class wraps three possible serialisation systems, providing a common interface to them all.
+  #
+  # It's not a necessary part of SimpleRPC---you may use any object that supports load/dump---but it is
+  # rather handy.
+  class Serialiser
+
+    SUPPORTED_METHODS = %w{marshal json msgpack yaml}.map{|s| s.to_sym}
+
+    # Create a new Serialiser with the given method.  Optionally provide a binding to have
+    # the serialisation method execute within another context, i.e. for it to pick up
+    # on various libraries and classes.
+    #
+    # Supported methods are:
+    #
+    # :marshal:: Use ruby's Marshal system.  A good mix of speed and generality.
+    # :yaml:: Use YAML.  Very slow but very general
+    # :msgpack:: Use MessagePack gem.  Very fast but not very general (limited data format support)
+    # :json::  Use JSON.  Also slow, but better for interoperability than YAML.
+    #
+    def initialize(method = :marshal, binding=nil)
+      @method   = method
+      @binding  = nil
+      raise "Unrecognised serialisation method" if not SUPPORTED_METHODS.include?(method)
+
+      # Require prerequisites and handle msgpack not installed-iness.
+      case method
+        when :msgpack
+          begin 
+            gem "msgpack", "~> 0.5"
+          rescue Gem::LoadError => e
+            $stderr.puts "The :msgpack serialisation method requires the MessagePack gem (msgpack)."
+            $stderr.puts "Please install it or use another serialisation method."
+            raise e
+          end
+          require 'msgpack'
+          @cls = MessagePack
+        when :yaml
+          require 'yaml'
+          @cls = YAML
+        when :json
+          require 'json'
+          @cls = JSON
+        else
+          # marshal is alaways available
+          @cls = Marshal
+      end
+    end
+
+    # Serialise to a string
+    def dump(obj)
+      return eval("#{@cls.to_s}.dump(obj)", @binding) if @binding
+      return @cls.send(:dump, obj)
+    end
+
+    # Deserialise from a string
+    def load(bits)
+      return eval("#{@cls.to_s}.load(bits)", @binding) if @binding
+      return @cls.send(:load, bits)
+    end
+
+  end
+
+end
+

data/lib/simplerpc/server.rb

@@ -0,0 +1,138 @@
+
+
+require 'socket'               # Get sockets from stdlib
+require 'simplerpc/serialiser'
+require 'simplerpc/socket_protocol'
+
+module SimpleRPC 
+
+  # SimpleRPC's server.  This wraps an object and exposes its methods to the network.
+  class Server
+
+    # Create a new server for a given proxy object
+    #
+    # proxy:: The object to proxy the API for---any ruby object
+    # port:: The port to listen on
+    # hostname:: The ip of the interface to listen on, or nil for all
+    # serialiser:: The serialiser to use
+    # threaded:: Should the server support multiple clients at once?
+    # timeout:: Socket timeout
+    def initialize(proxy, port, hostname=nil, serialiser=Serialiser.new, threaded=false, timeout = nil)
+      @proxy = proxy
+      @port = port
+      @hostname = hostname
+
+      # What format to use.
+      @serialiser = serialiser
+
+      # Silence errors?
+      @silence_errors = true
+
+      # Should we shut down?
+      @close  = false
+
+      # Connect/receive timeouts
+      @timeout = timeout
+
+      # Threaded or not?
+      @threaded = (threaded == true)
+      @clients = {} if @threaded
+      @m = Mutex.new if @threaded
+    end
+
+    # Start listening forever
+    def listen
+      # Listen on one interface only if hostname given
+      if @hostname
+        @s = TCPServer.open( @hostname, @port )
+      else
+        @s = TCPServer.open(@port)
+      end
+
+      # Handle clients
+      loop{
+
+        begin
+          if @threaded
+  
+            # Create the thread
+            id = rand.hash
+            thread = Thread.new(id, @m, @s.accept){|id, m, c|  
+              handle_client(c)
+
+              puts "#{id} closing 1"
+              m.synchronize{
+                @clients.delete(id)
+              }
+              puts "#{id} closing 2"
+            }
+
+            # Add to the client list
+            @m.synchronize{
+              @clients[id] = thread
+            }
+          else
+            handle_client(@s.accept)
+          end
+        rescue StandardError => e
+          raise e if not @silence_errors
+        end
+
+        break if @close
+      }
+    end
+
+    # Return the number of active clients.
+    def active_clients
+      @m.synchronize{
+        @clients.length
+      }
+    end
+
+    # Close the server object nicely,
+    # waiting on threads if necessary
+    def close
+      # Ask the loop to close
+      @close = true
+
+      # Wait on threads
+      if @threaded then
+        @clients.each{|id, thread|
+          thread.join
+        }
+      end
+    end
+
+  private
+    # Handle the protocol for client c
+    def handle_client(c)
+      m, arity = recv(c)
+
+      # Check the call is valid for the proxy object
+      valid_call = (@proxy.respond_to?(m) and @proxy.method(m).arity == arity)
+
+      send(c, valid_call)
+
+      # Make the call if valid and send the result back
+      if valid_call then
+        args = recv(c)
+        send(c, @proxy.send(m, *args) )
+      end
+
+      c.close
+    end
+
+    # Receive data from a client
+    def recv(c)
+      @serialiser.load( SocketProtocol::recv(c, @timeout) )
+    end
+
+    # Send data to a client
+    def send(c, obj)
+      SocketProtocol::send(c, @serialiser.dump(obj), @timeout)
+    end
+  end
+
+
+end
+

data/lib/simplerpc/socket_protocol.rb

@@ -0,0 +1,42 @@
+# Low-level protocol specification for SimpleRPC.
+#
+# This defines how data is sent at the socket level, primarily controlling what happens with partial sends/timeouts.
+module SimpleRPC::SocketProtocol
+  
+    # Send already-serialised payload to socket s
+    def self.send(s, payload, timeout=nil)
+      # Send length
+      raise Timeout::TimeoutError if not IO.select(nil, [s], nil, timeout)
+      s.puts(payload.length.to_s)
+
+      # Send rest incrementally
+      #puts "[s] send(#{payload})"
+      len = payload.length
+      while( len > 0 and x = IO.select(nil, [s], nil, timeout) )
+        len -= s.write( payload )
+      end
+      raise Timeout::TimeoutError if not x
+      #puts "[s] sent(#{payload})"
+    end
+
+    # Receive raw data from socket s.
+    def self.recv(s, timeout=nil)
+      # Read the length of the data
+      raise Timeout::TimeoutError if not IO.select([s], nil, nil, timeout)
+      len = s.gets.chomp.to_i
+
+      # Then read the rest incrementally
+      buf = ""
+      while( len > 0 and x = IO.select([s], nil, nil, timeout) )
+        #puts "[s (#{len})]"
+        x = s.read(len)
+        len -= x.length
+        buf += x
+      end
+      raise Timeout::TimeoutError if not x
+
+      return buf
+      #puts "[s] recv(#{buf})"
+    end
+
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: simplerpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0c
+platform: ruby
+authors:
+- Stephen Wattam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-23 00:00:00.000000000 Z
+dependencies: []
+description: A very simple and fast RPC library
+email: stephenwattam@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/simplerpc/client.rb
+- lib/simplerpc/server.rb
+- lib/simplerpc/socket_protocol.rb
+- lib/simplerpc/serialiser.rb
+- LICENSE
+homepage: http://stephenwattam.com/projects/simplerpc
+licenses:
+- Beer
+metadata: {}
+post_install_message: Have fun Cing RPs :-)
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Simple RPC library
+test_files: []