arpie 0.0.2 → 0.0.3

data/README

@@ -1,11 +1,13 @@
 = What's this?
 
-Arpie is a end-to-end framework for sending synchronous message-and-answer
-pairs, and serves as the basis for a RPC framework, handling a variety of protocols,
-including a generic Marshal proof of concept; writing your own Protocol is quite simple.
+Arpie is a end-to-end framework for sending protocol-encoded messages over arbitary
+IO channels, including UNIX/TCP Sockets, Pipes, and pidgeon carriers (depending on
+your implementation details).
 
-* It uses ruby threads on the server side, one per connection.
-* The client is single-threaded.
+Arpie also provides a robust replay-protected RPC framework.
+
+The Arpie server uses one ruby-thread per client, the client runs entirely in the
+calling thread; though an example implementation for evented callbacks is provided.
 
 == Source Code
 
@@ -36,7 +38,7 @@ to get the newest version.
   end
 
   c = Arpie::Client.new(Arpie::MarshalProtocol.new)
-  c.connect do |transport|
+  c.connect do
     TCPSocket.new("127.0.0.1", 51210)
   end
 
@@ -85,14 +87,17 @@ See the Client accessors for modifying this behaviour.
 It is assumed that each call, that is being placed, is atomic - eg, no
 connection losses in between message send and receive; lost messages
 will be retransmitted. Some Protocol classes provide support for replay
-protection through in-band serials; though it is not a requirement to implement it.
-If a serial is provided in the data stream, the Protocol will not call
+protection through in-band UUIDs; though it is not a requirement to implement it.
+If a UUID is provided in the data stream, the Protocol will not call
 the handler again for retransmissions, but instead reply with the old,
 already evaluated value.
 
-Not all protocols support serials; those who do not offer no replay protection,
+Not all protocols support UUIDs; those who do not offer no replay protection,
 and special care has to be taken elsewhere.
 
+All object-encoding protocols support UUIDs, including YAML and Marshal.
+XMLRPC does not.
+
 == Benchmarks
 
 There is a benchmark script included in the git repository (and in the gem
@@ -101,11 +106,13 @@ under tools/). A sample output follows; your milage may vary.
         user     system      total        real
 
   native DRb
-     1  0.000000   0.000000   0.000000 (  0.000167)
-  1000  0.120000   0.010000   0.130000 (  0.121834)
+     1  0.000000   0.000000   0.000000 (  0.000172)
+  1000  0.110000   0.010000   0.120000 (  0.119767)
 
-  ruby xmlrpc/server - too slow to benchmark
+  Arpie: proxied MarshalProtocol with replay protection through uuidtools
+     1  0.000000   0.000000   0.010000 (  0.075373)
+  1000  0.530000   0.090000   0.600000 (  0.608665)
 
-  Arpie: proxied MarshalProtocol
-     1  0.000000   0.000000   0.000000 (  0.000617)
-  1000  0.100000   0.020000   0.120000 (  0.114573)
+  Arpie: proxied MarshalProtocol without replay protection
+     1  0.000000   0.000000   0.000000 (  0.000173)
+  1000  0.170000   0.020000   0.190000 (  0.194649)

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "arpie"
-VERS = "0.0.2"
+VERS = "0.0.3"
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   "#{NAME}: A high-performing layered networking protocol framework. Simple to use, simple to extend.", \
@@ -44,6 +44,7 @@ spec = Gem::Specification.new do |s|
   s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib,tools,scripts,data}/**/*")
   s.require_path = "lib"
   s.bindir = "bin"
+  s.add_dependency('uuidtools', '>= 1.0.7')
 end
 
 Rake::GemPackageTask.new(spec) do |p|

data/lib/arpie/client.rb

@@ -106,6 +106,7 @@ module Arpie
     def _connect
       @read_io and return
       @read_io, @write_io = @connector.call(self)
+      @protocol.reset
       @write_io ||= @read_io
     end
   end

data/lib/arpie/protocol.rb

@@ -182,7 +182,7 @@ module Arpie
   class RPCProtocol < Protocol
 
     # A RPC call.
-    class Call < Struct.new(:ns, :meth, :argv); end
+    class Call < Struct.new(:ns, :meth, :argv, :uuid); end
   end
 
   # A XMLRPC Protocol based on rubys xmlrpc stdlib.

data/lib/arpie/proxy.rb

@@ -1,3 +1,5 @@
+require 'uuidtools'
+
 module Arpie
 
   # A Endpoint which supports arbitary objects as handlers,
@@ -6,30 +8,61 @@ module Arpie
   # Note that this will only export public instance method
   # of the class as they are defined.
   class ProxyServer < Server
+
+    # An array containing symbols of method names that the
+    # handler should be allowed to call. Defaults to
+    # all public instance methods the class defines (wysiwyg).
+    # Set this to nil to allow calling of ALL methods, but be
+    # warned of the security implications (instance_eval, ..).
     attr_accessor :interface
 
-    # Set a class handler. All instance methods will be
-    # callable over RPC (with a Proxy object).
-    # Consider yourself warned of the security implications:
-    #  proxy.instance_eval ..
-    # Optional interface parameter is an array of method
-    # names (as symbols). If given, only those will be
-    # accessible for Transports.
-    def handle handler, interface = nil
+    # Set this to false to disable replay protection.
+    attr_accessor :uuid_tracking
+
+    # The maximum number of method call results to remember.
+    # Defaults to 100, which should be enough for everyone. ;)
+    attr_accessor :max_uuids
+
+    def initialize *va
+      super
+      @uuids = {}
+      @max_uuids = 100
+      @uuid_tracking = true
+    end
+
+    # Set a class handler. All public instance methods will be
+    # callable over RPC (with a Proxy object) (see attribute interface).
+    def handle handler
       @handler = handler
-      @interface = interface
+      @interface = handler.class.public_instance_methods(false).map {|x|
+        x.to_sym
+      }
       self
     end
 
     private
 
     def _handle endpoint, message
-      if !@handler.respond_to?(message.meth) || (@interface && !@interface.index(message.meth))
+      if !@handler.respond_to?(message.meth.to_sym) ||
+          (@interface && !@interface.index(message.meth.to_sym))
         raise NoMethodError, "No such method: #{message.meth.inspect}"
       end
 
-      ret = @handler.send(message.meth, *message.argv)
-      endpoint.write_message(ret)
+      # Prune old serials. This can probably be optimized, but works well enough for now.
+      if @uuid_tracking && message.uuid
+        timestamps = @uuids.values.map {|v| v[0] }.sort
+        latest_timestamp = timestamps[-@max_uuids]
+        @uuids.reject! {|uuid, (time, value)|
+          time < latest_timestamp
+        } if latest_timestamp
+
+        endpoint.write_message((@uuids[message.uuid] ||=
+          [Time.now, @handler.send(message.meth, *message.argv)])[1])
+
+      else
+        endpoint.write_message @handler.send(message.meth, *message.argv)
+      end
+
     end
   end
 
@@ -39,11 +72,30 @@ module Arpie
   class ProxyClient < RPCClient
 
     def initialize protocol, namespace = ""
+      super(protocol)
       @protocol, @namespace = protocol, namespace
+      @uuid_generator = lambda {|client, method, argv|
+        UUID.timestamp_create.to_i.to_s
+      }
+    end
+
+    # Set up a new UUID generator for this proxy client.
+    # Make sure that this yields really random numbers.
+    # The default uses the uuidtools gem and is usually okay.
+    # You can simply set this to nil (by calling it without
+    # a block).
+    #
+    # Note that disabling this disables replay protection.
+    def uuid_generator &handler #:yields: client, method, argv
+      @uuid_generator = handler
+      self
     end
 
     def method_missing meth, *argv # :nodoc:
-      call = RPCProtocol::Call.new(@namespace, meth, argv)
+      uuid = @uuid_generator ?
+        @uuid_generator.call(self, meth, argv) : nil
+
+      call = RPCProtocol::Call.new(@namespace, meth, argv, uuid)
       ret = self.request(call)
       case ret
         when Exception

data/lib/arpie/server.rb

@@ -7,18 +7,19 @@ module Arpie
   class Endpoint
     attr_reader :io
 
-    attr_reader :server
+    attr_reader :protocol
 
-    def initialize server, io
-      @io, @server = io, server
+    def initialize protocol, io
+      @protocol, @io = protocol, io
+      @protocol.reset
     end
 
     def read_message
-      @server.protocol.read_message(@io)
+      @protocol.read_message(@io)
     end
 
     def write_message message
-      @server.protocol.write_message(@io, message)
+      @protocol.write_message(@io, message)
     end
     alias_method :<<, :write_message
 
@@ -119,7 +120,7 @@ module Arpie
     def _acceptor_thread
       loop do
         client = @acceptor.call(self)
-        c = @protocol.endpoint_klass.new(self, client)
+        c = @protocol.endpoint_klass.new(@protocol.clone, client)
         Thread.new { _read_thread(c) }
       end
     end

data/tools/benchmark.rb

@@ -39,27 +39,13 @@ Benchmark.bm {|b|
   b.report("1000") { 1000.times { drbobject.reverse "benchmark" } }
 
   puts ""
-  puts "ruby xmlrpc/server - too slow to benchmark"
-  #server = XMLRPC::Server.new(51211, "127.0.0.1", 4, nil, false)
-  #server.add_handler(XMLRPC::iPIMethods("wrap"), Wrap.new)
-  #server_thread = Thread.new { server.serve }
-  #client = XMLRPC::Client.new( "127.0.0.1", "/", 51211)
-  #b.report("   1") {    1.times { client.call("wrap.reverse", "benchmark") } }
-  #b.report("1000") { 1000.times { client.call("wrap.reverse", "benchmark") } }
-  #server.shutdown
-  #server_thread.join
-
-  puts ""
-  puts "Arpie: proxied MarshalProtocol"
+  puts "Arpie: proxied MarshalProtocol with replay protection through uuidtools"
   b.report("   1") {    1.times { $proxy.reverse "benchmark" } }
   b.report("1000") { 1000.times { $proxy.reverse "benchmark" } }
 
-
-  def evented_call
-    $transport.request(ProxyCall.new("reverse",["benchmark"])) do end
-  end
   puts ""
-#  puts "Arpie: evented messaging"
-#  b.report("   1") {    1.times { evented_call } }
-#  b.report("1000") { 1000.times { evented_call } }
+  puts "Arpie: proxied MarshalProtocol without replay protection"
+  $proxy.uuid_generator
+  b.report("   1") {    1.times { $proxy.reverse "benchmark" } }
+  b.report("1000") { 1000.times { $proxy.reverse "benchmark" } }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: arpie
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Bernhard Stoeckner
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-10 00:00:00 +01:00
+date: 2009-02-11 00:00:00 +01:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.7
+    version: 
 description: A high-performing layered networking protocol framework. Simple to use, simple to extend.
 email: elven@swordcoast.net
 executables: []