arpie 0.0.1 → 0.0.2

data/README

@@ -13,6 +13,9 @@ Source code is in git[http://git.swordcoast.net/?p=lib/ruby/arpie.git;a=summary]
 
 You can contact me via email at elven@swordcoast.net.
 
+arpie is available on the rubygems gem server - just do <tt>gem1.8 install arpie</tt>
+to get the newest version.
+
 
 == Simple, contrived example: A string reverse server
 
@@ -22,22 +25,23 @@ You can contact me via email at elven@swordcoast.net.
 
   server = TCPServer.new(51210)
 
-  e = Arpie::Endpoint.new(Arpie::MarshalProtocol.new)
+  e = Arpie::Server.new(Arpie::MarshalProtocol.new)
 
-  e.handle do |ep, msg|
-    msg.reverse
+  e.handle do |server, ep, msg|
+    ep.write_message msg.reverse
   end
 
   e.accept do
     server.accept
   end
 
-  c = Arpie::Transport.new(Arpie::MarshalProtocol.new)
+  c = Arpie::Client.new(Arpie::MarshalProtocol.new)
   c.connect do |transport|
     TCPSocket.new("127.0.0.1", 51210)
   end
 
-  puts c.request "hi"
+  c.write_message "hi"
+  puts c.read_message
   # => "ih"
 
 == Advanced, but still simple example: Using Proxy to access remote objects
@@ -54,7 +58,7 @@ You can contact me via email at elven@swordcoast.net.
 
   server = TCPServer.new(51210)
 
-  e = Arpie::ProxyEndpoint.new(Arpie::MarshalProtocol.new)
+  e = Arpie::ProxyServer.new(Arpie::MarshalProtocol.new)
 
   e.handle MyHandler.new
 
@@ -62,15 +66,33 @@ You can contact me via email at elven@swordcoast.net.
     server.accept
   end
 
-  c = Arpie::Transport.new(Arpie::MarshalProtocol.new)
-  c.connect do |transport|
+  p = Arpie::ProxyClient.new(Arpie::MarshalProtocol.new)
+  p.connect do |transport|
     TCPSocket.new("127.0.0.1", 51210)
   end
-  p = Arpie::Proxy.new(c)
 
   puts p.reverse "hi"
   # => "ih"
 
+
+== Replay protection
+
+It can happen that a Client loses connection to a Server.
+In that case, the Transport tries transparently reconnecting by simply
+invoking the block again that was given to Client#connect.
+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
+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,
+and special care has to be taken elsewhere.
+
 == Benchmarks
 
 There is a benchmark script included in the git repository (and in the gem

data/Rakefile

@@ -9,10 +9,10 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "arpie"
-VERS = "0.0.1"
+VERS = "0.0.2"
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
-  "#{NAME}: A high-performing layered RPC framework. Simple to use, simple to extend.", \
+  "#{NAME}: A high-performing layered networking protocol framework. Simple to use, simple to extend.", \
   '--main', 'README']
 
 DOCS = ["README", "COPYING"]
@@ -34,7 +34,7 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   s.extra_rdoc_files = DOCS + Dir["doc/*.rdoc"]
   s.rdoc_options += RDOC_OPTS + ["--exclude", "^(examples|extras)\/"]
-  s.summary = "a synchronous RPC library based on google protobuf"
+  s.summary = "A high-performing layered networking protocol framework. Simple to use, simple to extend."
   s.description = s.summary
   s.author = "Bernhard Stoeckner"
   s.email = "elven@swordcoast.net"

data/lib/arpie.rb

@@ -1,4 +1,4 @@
 require 'arpie/protocol'
-require 'arpie/transport'
-require 'arpie/endpoint'
+require 'arpie/server'
+require 'arpie/client'
 require 'arpie/proxy'

data/lib/arpie/client.rb

@@ -0,0 +1,193 @@
+module Arpie
+
+  # A Client is a connection manager, and acts as the
+  # glue between a user-defined medium (for example, a TCP
+  # socket), and a protocol, with automatic reconnecting
+  # and fault handling.
+  #
+  # See README for examples.
+  class Client
+    attr_reader :protocol
+
+    # How often should this Client retry a connection.
+    # 0 for never, greater than 0 for that many attempts,
+    # nil for infinite (default).
+    # Values other than nil will raise network exceptions
+    # to the caller.
+    attr_accessor :connect_retry
+
+    # How long should the caller sleep after each reconnect
+    # attempt. (default: 1.0). The default value is probably
+    # okay. Do not set this to 0; that will produce
+    # unnecessary load in case of network failure.
+    attr_accessor :connect_sleep
+
+    def initialize protocol
+      @protocol = protocol
+      @read_io = nil
+      @write_io = nil
+      @connector = lambda { raise ArgumentError, "No connector specified, cannot connect to Endpoint." }
+      @connect_retry = nil
+      @connect_sleep = 1.0
+      @on_error = lambda {|client, exception|
+        $stderr.puts "Error in Transport IO: #{exception.message.to_s}"
+        $stderr.puts exception.backtrace.join("\n")
+        $stderr.puts "Set Transport#on_error &block to override this."
+      }
+    end
+
+    # Provide a connector block, which will be called
+    # each time a connection is needed.
+    # Expectes an IO object.
+    # Alternatively, you can return a two-item array.
+    # To test something without involving any networking,
+    # simply run IO.pipe in this block.
+    # Set +connect_immediately+ to true to connect
+    # immediately, instead on the first message.
+    def connect connect_immediately = false, &connector
+      @connector = connector
+      _connect if connect_immediately
+      self
+    end
+
+    # Set an error handler. It will be called with two
+    # parameters, the client, and the exception that occured.
+    # Optional, and just for notification.
+    def on_error &handler #:yields: client, exception
+      @on_error = handler
+      self
+    end
+
+    # Send a message. Returns immediately.
+    def write_message message
+      io_retry do
+        @protocol.write_message(@write_io, message)
+      end
+    end
+    alias_method :<<, :write_message
+
+    # Receive a message. Blocks until received.
+    def read_message
+      io_retry do
+        message = @protocol.read_message(@read_io)
+      end
+    end
+
+    # Execute the given block until all connection attempts
+    # have been exceeded.
+    # Yields self.
+    # You do not usually want to use this.
+    def io_retry &block
+      try = 0
+
+      begin
+        _connect
+        yield self
+      rescue IOError => e
+        try += 1
+        @on_error.call(self, e) if @on_error
+        p e
+
+        if @connect_retry == 0 || (@connect_retry && try > @connect_retry)
+          raise EOFError, "Cannot read from io: lost connection after #{try} attempts (#{e.message.to_s})"
+        end
+
+        sleep @connect_sleep
+        begin; @read_io.close if @read_io; rescue; end
+        @read_io = nil
+        begin; @write_io.close if @write_io; rescue; end
+        @write_io = nil
+        retry
+      end
+    end
+
+  private
+
+    def _connect
+      @read_io and return
+      @read_io, @write_io = @connector.call(self)
+      @write_io ||= @read_io
+    end
+  end
+
+  # A simple pseudo event-based client, using a thread
+  # with a callback.
+  class EventedClient < Client
+    private :read_message
+
+    # Set a callback for incoming messages.
+    def handle &handler #:yields: client, message
+      @handler = handler
+    end
+
+  private
+
+    def _read_thread
+      loop do
+        io_retry do
+          message = read_message
+          @handler and @handler.call(self, message)
+        end
+      end
+    end
+
+    def _connect
+      super
+      @read_thread ||= Thread.new { _read_thread }
+    end
+  end
+
+
+  # A Client extension which provides a RPC-like
+  # interface. Used by ProxyClient.
+  class RPCClient < Client
+    private :read_message, :write_message
+
+    def initialize protocol
+      super(protocol)
+
+      @on_pre_call = lambda {|client, message| }
+      @on_post_call = lambda {|client, message, reply| }
+    end
+
+    # Callback that gets invoked before placing a call to the
+    # Server. You can stop the call from happening by raising
+    # an exception (which will be passed on to the caller).
+    def pre_call &handler #:yields: client, message
+      @on_pre_call = handler
+      self
+    end
+
+    # Callback that gets invoked after receiving an answer.
+    # You can raise an exception here; and it will be passed
+    # to the caller, instead of returning the value.
+    def post_call &handler #:yields: client, message, reply
+      @on_post_call = handler
+      self
+    end
+
+
+    # Send a message and receive a reply in a synchronous
+    # fashion. Will block until transmitted, or until
+    # all reconnect attempts failed.
+    def request message
+      reply = nil
+
+      @on_pre_call.call(self, message) if @on_pre_call
+
+      io_retry do
+        write_message(message)
+        reply = read_message
+      end
+
+      @on_post_call.call(self, message, reply) if @on_post_call
+
+      case reply
+        when Exception
+          raise reply
+        else
+          reply
+      end
+    end
+  end
+end

data/lib/arpie/protocol.rb

@@ -1,51 +1,280 @@
+require 'shellwords'
+require 'yaml'
+
 module Arpie
 
   # A Protocol converts messages (which are arbitary objects)
   # to a suitable on-the-wire format, and back.
   class Protocol
+    MTU = 1024
+
     private_class_method :new
 
+    attr_reader :message
+
+    def initialize
+      @message = nil
+      @buffer = ""
+      reset
+    end
+
+    # Reads data from +io+. Returns true, if a whole
+    # message has been read, or false if more data is needed.
+    # The read message can be retrieved via Protocol#message.
+    def read_partial io
+      @buffer << io.readpartial(MTU)
+
+      if idx = complete?(@buffer)
+        @message = from @buffer[0, idx]
+        @buffer = @buffer[idx, -1] || ""
+        return true
+      end
+
+      return false
+    end
+
     # Read a message from +io+. Block until a message
     # has been received.
+    # Returns the message.
     def read_message io
+      select([io]) until read_partial(io)
+      @message
     end
 
-    # Write a message to +io+.
+    def write_raw_partial io, message
+      io.write(message)
+    end
+
+    # Write +message+ to +io+.
     def write_message io, message
+      io.write(to message)
+    end
+
+    # Convert obj to on-the-wire format.
+    def to obj
+      obj
+    end
+
+    # Convert obj from on-the-wire-format.
+    def from obj
+      obj
+    end
+
+    # Returns a Fixnum if the given obj contains a complete message.
+    # The Fixnum is the index up to where the message runs; the rest
+    # is assumed to be (part of) the next message.
+    # Returns nil if obj does not describe a complete message (eg,
+    # more data needs to be read).
+    def complete? obj
+      nil
+    end
+
+    # Reset all state buffers. This is usually called
+    # when the underlying connection drops, and any half-read
+    # messages need to be discarded.
+    def reset
+      @message = nil
+      @buffer = ""
+    end
+
+    def endpoint_klass
+      Arpie::Endpoint
     end
   end
 
-  # A sample binary protocol, upon which others can expand.
-  # The on the wire format is simply the data, prefixed
-  # with data.size.
+  # A simple separator-based protocol. This can be used to implement
+  # newline-delimited communication.
+  class SeparatorProtocol < Protocol
+    public_class_method :new
+
+    attr_accessor :separator
+
+    def initialize separator = "\n"
+      super()
+      @separator = separator
+    end
+
+    def complete? obj
+      obj.index(@separator)
+    end
+
+    def from obj
+      obj.gsub(/#{Regexp.escape(@separator)}$/, "")
+    end
+
+    def to obj
+      obj + @separator
+    end
+  end
+
+  # A linebased-protocol, which does shellwords-escaping/joining
+  # on the lines; messages sent are arrays of parameters.
+  # Note that all parameters are expected to be strings.
+  class ShellwordsProtocol < SeparatorProtocol
+    def to obj
+      super Shellwords.join(obj)
+    end
+
+    def from obj
+      Shellwords.shellwords(super obj)
+    end
+  end
+
+  # A sample binary protocol, which simply prefixes each message with the
+  # size of the data to be expected.
   class SizedProtocol < Protocol
+    public_class_method :new
+
     def initialize
+      super
       @max_message_size = 1024 * 1024
     end
 
-    def read_message io
-      sz = io.read(8)
-      expect = sz.unpack("Q")[0]
-      data = io.read(expect)
+    def complete? obj
+      sz = obj.unpack("Q")[0]
+      obj.size == sz + 8 ? sz + 8 : nil
     end
 
-    def write_message io, message
-      io.write([message.size, message].pack("Qa*"))
+    def from obj
+      sz, data = obj.unpack("Qa*")
+      data
+    end
+
+    def to obj
+      [obj.size, obj].pack("Qa*")
     end
   end
 
   # A procotol that simply Marshals all data sent over
   # this protocol. Served as an example, but a viable
   # choice for ruby-only production code.
+  # Messages are arbitary objects.
   class MarshalProtocol < SizedProtocol
+    def to obj
+      super Marshal.dump(obj)
+    end
+
+    def from obj
+      Marshal.load(super obj)
+    end
+  end
+
+  # A protocol which encodes objects into YAML representation.
+  # Messages are arbitary yaml-encodable objects.
+  class YAMLProtocol < Arpie::Protocol
     public_class_method :new
 
-    def read_message io
-      Marshal.load super(io)
+    def complete? obj
+      obj =~ /\.\.\.$/
     end
 
-    def write_message io, message
-      super io, Marshal.dump(message)
+    def to obj
+      YAML.dump(obj) + "...\n"
+    end
+
+    def from obj
+      YAML.load(obj)
+    end
+  end
+
+  # A RPC Protocol encapsulates RPCProtocol::Call
+  # messages.
+  class RPCProtocol < Protocol
+
+    # A RPC call.
+    class Call < Struct.new(:ns, :meth, :argv); end
+  end
+
+  # A XMLRPC Protocol based on rubys xmlrpc stdlib.
+  # This does not encode HTTP headers; usage together with
+  # a real webserver is advised.
+  class XMLRPCProtocol < RPCProtocol
+    public_class_method :new
+
+    require 'xmlrpc/create'
+    require 'xmlrpc/parser'
+    require 'xmlrpc/config'
+
+    VALID_MODES = [:client, :server].freeze
+
+    attr_reader :mode
+    attr_accessor :writer
+    attr_accessor :parser
+
+    def initialize mode, writer = XMLRPC::Create, parser = XMLRPC::XMLParser::REXMLStreamParser
+      super()
+      raise ArgumentError, "Not a valid mode, expecting one of #{VALID_MODES.inspect}" unless
+        VALID_MODES.index(mode)
+
+      @mode = mode
+      @writer = writer.new
+      @parser = parser.new
+    end
+
+    def to obj
+      case @mode
+        when :client
+          @writer.methodCall(obj.ns + obj.meth, *obj.argv)
+
+        when :server
+          case obj
+            when Exception
+              # TODO: wrap XMLFault
+            else
+              @writer.methodResponse(true, obj)
+            end
+      end
+    end
+
+    def from obj
+      case @mode
+        when :client
+          @parser.parseMethodResponse(obj)[1]
+
+        when :server
+          vv = @parser.parseMethodCall(obj)
+          RPCProtocol::Call.new('', vv[0], vv[1])
+      end
+    end
+
+    def complete? obj
+      case @mode
+        when :client
+          obj.index("</methodResponse>")
+        when :server
+          obj.index("</methodCall>")
+      end
+    end
+  end
+
+  # This simulates a very basic HTTP XMLRPC client/server.
+  # It is not recommended to use this with production code.
+  class HTTPXMLRPCProtocol < XMLRPCProtocol
+    def to obj
+      r = super
+      case @mode
+        when :client
+          "GET / HTTP/1.[01]\r\nContent-Length: #{r.size}\r\n\r\n" + r
+        when :server
+          "HTTP/1.0 200 OK\r\nContent-Length: #{r.size}\r\n\r\n" + r
+      end
+    end
+
+    def from obj
+      # Simply strip all HTTP headers.
+      header, obj = obj.split(/\r\n\r\n/, 2)
+      super(obj)
+    end
+
+
+    def complete? obj
+      # Complete if: has headers, has content-length, has data of content-length
+      header, body = obj.split(/\r\n\r\n/, 2)
+
+      header =~ /content-length:\s+(\d+)/i or return nil
+
+      content_length = $1.to_i
+      body.size == content_length ? header.size + 4 + body.size : nil
     end
   end
 end

data/lib/arpie/proxy.rb

@@ -1,40 +1,50 @@
 module Arpie
 
-  # The RPC call encapsulation used by ProxyEndpoint and Proxy.
-  class ProxyCall < Struct.new(:method, :argv); end
-
   # A Endpoint which supports arbitary objects as handlers,
   # instead of a proc.
   #
   # Note that this will only export public instance method
   # of the class as they are defined.
-  class ProxyEndpoint < Endpoint
-    def handle handler
+  class ProxyServer < Server
+    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
       @handler = handler
-      @interface = @handler.class.public_instance_methods(false)
+      @interface = interface
+      self
     end
 
     private
 
-    def _handle message
-      @interface.index(message.method.to_s) or raise NoMethodError,
-        "Unknown method."
-      @handler.send(message.method, *message.argv)
+    def _handle endpoint, message
+      if !@handler.respond_to?(message.meth) || (@interface && !@interface.index(message.meth))
+        raise NoMethodError, "No such method: #{message.meth.inspect}"
+      end
+
+      ret = @handler.send(message.meth, *message.argv)
+      endpoint.write_message(ret)
     end
   end
 
-  # A Proxy is a wrapper around a transport, which transparently tunnels
-  # method calls to the remote ProxyEndpoint.
-  class Proxy
+  # A Proxy is a wrapper around a Client, which transparently tunnels
+  # method calls to the remote ProxyServer.
+  # Note that the methods of Client cannot be proxied.
+  class ProxyClient < RPCClient
 
-    # Create a new Proxy.
-    def initialize transport
-      @transport = transport
+    def initialize protocol, namespace = ""
+      @protocol, @namespace = protocol, namespace
     end
 
-    def method_missing method, *argv # :nodoc:
-      call = ProxyCall.new(method, argv)
-      ret = @transport.request(call)
+    def method_missing meth, *argv # :nodoc:
+      call = RPCProtocol::Call.new(@namespace, meth, argv)
+      ret = self.request(call)
       case ret
         when Exception
           raise ret

data/lib/arpie/server.rb

@@ -0,0 +1,156 @@
+module Arpie
+
+  # Endpoint wraps client IO objects. One Endpoint
+  # per client. This is provided as a convenience
+  # mechanism for protocols to store
+  # protocol-and-client-specific data.
+  class Endpoint
+    attr_reader :io
+
+    attr_reader :server
+
+    def initialize server, io
+      @io, @server = io, server
+    end
+
+    def read_message
+      @server.protocol.read_message(@io)
+    end
+
+    def write_message message
+      @server.protocol.write_message(@io, message)
+    end
+    alias_method :<<, :write_message
+
+  end
+
+  # A Server is the server-side part of a RPC setup.
+  # It accepts connections (via the acceptor), and handles
+  # incoming RPC calls on them.
+  #
+  # There will be one Thread per connection, so order of
+  # execution with multiple threads is not guaranteed.
+  class Server
+    attr_reader :protocol
+
+    attr_reader :endpoints
+
+    # Create a new Server with the given +Protocol+.
+    # You will need to define a handler, and an acceptor
+    # before it becomes operational.
+    def initialize protocol
+      @protocol = protocol
+      @endpoints = []
+
+      @on_connect = lambda {|server, endpoint| }
+      @on_disconnect = lambda {|server, endpoint, exception| }
+      @on_handler_error = lambda {|server, endpoint, message, exception|
+        $stderr.puts "Error in handler: #{exception.message.to_s}"
+        $stderr.puts exception.backtrace.join("\n")
+        $stderr.puts "Returning exception for this call."
+        Exception.new("internal error")
+      }
+      @handler = lambda {|server, endpoint, message| raise ArgumentError, "No handler defined." }
+    end
+
+    # Provide an acceptor; this will be run in a a loop
+    # to get IO objects.
+    #
+    # Example:
+    #  listener = TCPServer.new(12345)
+    #  my_server.accept do
+    #    listener.accept
+    #  end
+    def accept &acceptor #:yields: server
+      @acceptor = acceptor
+      Thread.new { _acceptor_thread }
+      self
+    end
+
+    # Set a message handler, which is a proc that will receive
+    # three parameters: the server, the endpoint, and the message.
+    #
+    # Example:
+    #  my_server.handle do |server, endpoint, message|
+    #    puts "Got a message: #{message.inspect}"
+    #    endpoint.write_message "ok"
+    #  end
+    def handle &handler #:yields: server, endpoint, message
+      raise ArgumentError, "No handler given; need a block or proc." unless handler
+      @handler = handler
+      self
+    end
+
+    # Set an error handler.
+    # The return value will be sent to the client.
+    #
+    # Default is to print the exception to stderr, and return
+    # a generic exception that does not leak information.
+    def on_handler_error &handler #:yields: server, endpoint, message, exception
+      raise ArgumentError, "No handler given; need a block or proc." unless handler
+      @on_handler_error = handler
+      self
+    end
+
+    # Callback that gets invoked when a new client connects.
+    # You can <tt>throw :kill_client</tt> here to stop this client
+    # from connecting. Clients stopped this way will invoke
+    # the on_disconnect handler normally.
+    def on_connect &handler #:yields: server, endpoint
+      raise ArgumentError, "No handler given; need a block or proc." unless handler
+      @on_connect = handler
+      self
+    end
+
+    # Callback that gets invoked when a client disconnects.
+    # The exception is the error that occured (usually a EOFError).
+    def on_disconnect &handler #:yields: server, endpoint, exception
+      raise ArgumentError, "No handler given; need a block or proc." unless handler
+      @on_disconnect = handler
+      self
+    end
+
+  private
+
+    def _handle endpoint, message
+      @handler.call(self, endpoint, message)
+    end
+
+    def _acceptor_thread
+      loop do
+        client = @acceptor.call(self)
+        c = @protocol.endpoint_klass.new(self, client)
+        Thread.new { _read_thread(c) }
+      end
+    end
+
+    def _read_thread endpoint
+      @endpoints << endpoint
+      _exception = nil
+
+      catch(:kill_client) {
+        @on_connect.call(self, endpoint)
+
+        loop do
+          message, answer = nil, nil
+
+          begin
+            message = endpoint.read_message
+          rescue IOError => e
+            _exception = e
+            break
+          end
+
+          begin
+            answer = _handle(endpoint, message)
+          rescue Exception => e
+            answer = @on_handler_error.call(self, endpoint, message, e)
+          end
+        end
+      }
+
+      @on_disconnect.call(self, endpoint, _exception)
+      @endpoints.delete(endpoint)
+    end
+  end
+end

data/tools/benchmark.rb

@@ -16,18 +16,17 @@ include Arpie
 
 server = TCPServer.new(51210)
 
-endpoint = ProxyEndpoint.new MarshalProtocol.new
+endpoint = ProxyServer.new MarshalProtocol.new
 endpoint.handle Wrap.new
 
 endpoint.accept do
   server.accept
 end
 
-$transport = Transport.new MarshalProtocol.new
-$transport.connect(false) do |transport|
+$proxy = ProxyClient.new MarshalProtocol.new
+$proxy.connect(true) do
   TCPSocket.new("127.0.0.1", 51210)
 end
-$proxy = Proxy.new $transport
 
 Benchmark.bm {|b|
 
@@ -54,4 +53,13 @@ Benchmark.bm {|b|
   puts "Arpie: proxied MarshalProtocol"
   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 } }
 }

data/tools/protocol_benchmark.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'socket'
+require 'arpie'
+require 'benchmark'
+
+include Arpie
+
+# Data test size.
+DATA_SIZE = 512
+
+rpc_call = RPCProtocol::Call.new('ns.', 'meth', [1, 2, 3, 4])
+$test_data = "a" * DATA_SIZE
+$test_data.freeze
+
+# Protocols to test:
+PROTOCOLS = {
+  MarshalProtocol => $test_data,
+  SizedProtocol => $test_data,
+  ShellwordsProtocol => $test_data,
+  SeparatorProtocol => $test_data,
+  YAMLProtocol => $test_data,
+#   XMLRPCProtocol => [rpc_call, :server],
+#  HTTPXMLRPCProtocol => [rpc_call, :client],
+}
+
+ITERATIONS = 1000
+
+$stderr.puts "Testing protocols with a data size of #{DATA_SIZE}, #{ITERATIONS} iterations"
+
+
+Benchmark.bm {|b|
+  r, w = IO.pipe
+  PROTOCOLS.each {|p, (d, a)|
+    a ||= []
+    proto = p.new(*a)
+    r, w = IO.pipe
+
+    b.report("%-30s" % p.to_s) {
+      ITERATIONS.times do
+        proto.write_message(w, d)
+        proto.read_message(r)
+      end
+    }
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: arpie
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Bernhard Stoeckner
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-18 00:00:00 +01:00
+date: 2009-02-10 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
-description: a synchronous RPC library based on google protobuf
+description: A high-performing layered networking protocol framework. Simple to use, simple to extend.
 email: elven@swordcoast.net
 executables: []
 
@@ -30,11 +30,12 @@ files:
 - spec/rcov.opts
 - lib/arpie.rb
 - lib/arpie
+- lib/arpie/client.rb
 - lib/arpie/protocol.rb
-- lib/arpie/transport.rb
-- lib/arpie/endpoint.rb
 - lib/arpie/proxy.rb
+- lib/arpie/server.rb
 - tools/benchmark.rb
+- tools/protocol_benchmark.rb
 has_rdoc: true
 homepage: http://arpie.elv.es
 post_install_message: 
@@ -43,7 +44,7 @@ rdoc_options:
 - --line-numbers
 - --inline-source
 - --title
-- "arpie: A high-performing layered RPC framework. Simple to use, simple to extend."
+- "arpie: A high-performing layered networking protocol framework. Simple to use, simple to extend."
 - --main
 - README
 - --exclude
@@ -68,6 +69,6 @@ rubyforge_project: arpie
 rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
-summary: a synchronous RPC library based on google protobuf
+summary: A high-performing layered networking protocol framework. Simple to use, simple to extend.
 test_files: []
 

data/lib/arpie/endpoint.rb

@@ -1,94 +0,0 @@
-module Arpie
-
-  # A Endpoint is the server-side part of a RPC setup.
-  # It accepts connections (via the acceptor), and handles
-  # incoming RPC calls on them.
-  #
-  # There will be one Thread per connection, so order of
-  # execution with multiple threads is not guaranteed.
-  class Endpoint
-
-    # Create a new Endpoint with the given +Protocol+.
-    # You will need to define a handler, and an acceptor
-    # before the endpoint becomes operational.
-    def initialize protocol
-      @protocol = protocol
-      @clients = []
-
-      @handler = lambda {|endpoint, message| raise ArgumentError, "No handler defined." }
-    end
-
-    # Provide an acceptor; this will be run in a a loop
-    # to get IO objects.
-    #
-    # Example:
-    #  listener = TCPServer.new(12345)
-    #  my_endpoint.accept do
-    #    listener.accept
-    #  end
-    def accept &acceptor
-      @acceptor = acceptor
-      Thread.new { _acceptor_thread }
-    end
-
-    # Set a message handler, which is a proc that will receive
-    # two parameters: the endpoint, and the message.
-    # Its return value will be sent as the reply.
-    #
-    # Example:
-    #  my_endpoint.handle do |endpoint, message|
-    #    puts "Got a message: #{message.inspect}"
-    #    "ok"
-    #  end
-    def handle &handler
-      raise ArgumentError, "need a block" unless block_given?
-      @handler = handler
-    end
-
-    private
-
-    def _handle message
-      @handler.call(self, message)
-    end
-
-    def _acceptor_thread
-      loop do
-        client = @acceptor.call(self)
-        @clients << client
-        Thread.new { _read_thread(client) }
-      end
-    end
-
-    def _read_thread client
-      loop do
-        break if client.eof?
-
-        message, answer = nil, nil
-        begin
-          message = @protocol.read_message(client)
-        rescue => e
-          $stderr.puts "client went away while reading the message: #{e.to_s}"
-          break
-        end
-
-        begin
-          answer = _handle(message)
-        rescue Exception => e
-          $stderr.puts "Error in handler: #{e.message.to_s}"
-          $stderr.puts e.backtrace.join("\n")
-          $stderr.puts "Returning exception for this call."
-          answer = e
-        end
-
-        begin
-          @protocol.write_message(client, answer)
-        rescue => e
-          puts "client went away while writing the answer:: #{e.to_s}"
-          break
-        end
-      end
-
-      @clients.delete(client)
-    end
-  end
-end

data/lib/arpie/transport.rb

@@ -1,37 +0,0 @@
-module Arpie
-
-  # A Transport is a connection manager, and acts as the
-  # glue between a user-defined medium (for example, a TCP
-  # socket), and a protocol.
-  #
-  # See README for examples.
-  class Transport
-    attr_reader :protocol
-
-    def initialize protocol
-      @protocol = protocol
-      @io = nil
-    end
-
-    # Provide a connector block, which will be called
-    # each time a connection is needed.
-    # Set +connect_immediately+ to true to connect
-    # immediately, instead on the first message.
-    def connect connect_immediately = false, &connector
-      @connector = connector
-      _connect if connect_immediately
-    end
-
-    # Send a message and receive a reply.
-    def request message
-      _connect
-      @protocol.write_message(@io, message)
-      @protocol.read_message(@io)
-    end
-
-    private
-    def _connect
-      @io ||= @connector.call(self)
-    end
-  end
-end