arpie 0.0.3 → 0.0.4

data/lib/arpie/proxy.rb

@@ -45,24 +45,34 @@ module Arpie
     def _handle endpoint, message
       if !@handler.respond_to?(message.meth.to_sym) ||
           (@interface && !@interface.index(message.meth.to_sym))
-        raise NoMethodError, "No such method: #{message.meth.inspect}"
+        endpoint.write_message NoMethodError.new("No such method: #{message.meth.inspect}")
+        return
       end
 
-      # 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
+      begin
+        # Prune old serials. This can probably be optimized, but works well enough for now.
+        if @uuid_tracking && message.uuid && message.uuid.is_a?(Numeric)
+          message.uuid &= 0xffffffffffffffff
 
-        endpoint.write_message((@uuids[message.uuid] ||=
-          [Time.now, @handler.send(message.meth, *message.argv)])[1])
+          timestamps = @uuids.values.map {|v| v[0] }.sort
+          latest_timestamp = timestamps[-@max_uuids]
+          @uuids.reject! {|uuid, (time, value)|
+            time < latest_timestamp
+          } if latest_timestamp
 
-      else
-        endpoint.write_message @handler.send(message.meth, *message.argv)
-      end
+          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
+      rescue IOError
+        raise
+
+      rescue Exception => e
+        endpoint.write_message RuntimeError.new("Internal Error")
+        raise
+      end
     end
   end
 
@@ -70,12 +80,13 @@ module Arpie
   # method calls to the remote ProxyServer.
   # Note that the methods of Client cannot be proxied.
   class ProxyClient < RPCClient
+    attr_accessor :namespace
 
-    def initialize protocol, namespace = ""
-      super(protocol)
-      @protocol, @namespace = protocol, namespace
+    def initialize *protocols
+      super
+      @protocol, @namespace = protocol, ""
       @uuid_generator = lambda {|client, method, argv|
-        UUID.timestamp_create.to_i.to_s
+        UUID.random_create.to_i
       }
     end
 
@@ -95,7 +106,7 @@ module Arpie
       uuid = @uuid_generator ?
         @uuid_generator.call(self, meth, argv) : nil
 
-      call = RPCProtocol::Call.new(@namespace, meth, argv, uuid)
+      call = Arpie::RPCall.new(@namespace, meth, argv, uuid)
       ret = self.request(call)
       case ret
         when Exception

data/lib/arpie/server.rb

@@ -36,11 +36,11 @@ module Arpie
 
     attr_reader :endpoints
 
-    # Create a new Server with the given +Protocol+.
+    # Create a new Server with the given protocols.
     # You will need to define a handler, and an acceptor
     # before it becomes operational.
-    def initialize protocol
-      @protocol = protocol
+    def initialize *protocols
+      @protocol = Arpie::ProtocolChain.new(*protocols)
       @endpoints = []
 
       @on_connect = lambda {|server, endpoint| }
@@ -120,7 +120,7 @@ module Arpie
     def _acceptor_thread
       loop do
         client = @acceptor.call(self)
-        c = @protocol.endpoint_klass.new(@protocol.clone, client)
+        c = @protocol.endpoint_class.new(@protocol.clone, client)
         Thread.new { _read_thread(c) }
       end
     end

data/lib/arpie/xmlrpc.rb

@@ -0,0 +1,108 @@
+require 'xmlrpc/create'
+require 'xmlrpc/parser'
+require 'xmlrpc/config'
+
+module Arpie
+
+  class XMLRPCProtocol < Protocol
+    private_class_method :new
+
+    attr_accessor :writer
+    attr_accessor :parser
+
+    def setup
+      @writer ||= XMLRPC::Create.new
+      @parser ||= XMLRPC::XMLParser::REXMLStreamParser.new
+    end
+    private :setup
+
+  end
+
+  # A XMLRPC Protocol based on rubys xmlrpc stdlib.
+  # This does not encode HTTP headers; usage together with
+  # a real webserver is advised.
+  class XMLRPCClientProtocol < XMLRPCProtocol
+    public_class_method :new
+
+    def to object
+      setup
+      raise ArgumentError, "Can only encode Arpie::RPCall" unless
+        object.is_a?(Arpie::RPCall)
+
+      @writer.methodCall((object.ns.nil? ? '' : object.ns + '.') + object.meth, *object.argv)
+    end
+
+    def from binary
+      setup
+      yield @parser.parseMethodResponse(binary)[1]
+    end
+  end
+
+  class XMLRPCServerProtocol < XMLRPCProtocol
+    public_class_method :new
+
+    def to object
+      setup
+      case object
+        when Exception
+          # TODO: wrap XMLFault
+          raise NotImplementedError, "Cannot encode exceptions"
+
+        else
+          @writer.methodResponse(true, object)
+      end
+    end
+
+    def from binary
+      setup
+      vv = @parser.parseMethodCall(binary)
+      ns, meth = vv[0].split('.')
+      meth.nil? and begin meth, ns = ns, nil end
+      yield RPCall.new(ns, meth, vv[1])
+    end
+  end
+
+  # This simulates a very basic HTTP XMLRPC client/server.
+  # It is not recommended to use this with production code.
+  class HTTPTestProtocol < Protocol
+    CAN_SEPARATE_MESSAGES = true
+
+    private_class_method :new
+
+    def from binary
+      # Simply strip all HTTP headers.
+      binary && binary.size > 0 or incomplete!
+      header, body_and_rest = binary.split(/\r\n\r\n/, 2)
+      header && body_and_rest or incomplete!
+
+      header =~ /^\s*content-length:\s+(\d+)$\s*/xi or stream_error! "No content-length was provided."
+      content_length = $1.to_i
+
+      content_length <= 0 
+      body_and_rest.size >= content_length or incomplete!
+
+      body = body_and_rest[0, content_length]
+
+      yield body
+
+      header.size + 4 + content_length
+    end
+  end
+
+  class HTTPClientTestProtocol < HTTPTestProtocol
+    public_class_method :new
+
+    def to object
+      "GET / HTTP/1.[01]\r\nContent-Length: #{object.size}\r\n\r\n" + object
+    end
+ 
+  end
+
+  class HTTPServerTestProtocol < HTTPTestProtocol
+    public_class_method :new
+
+    def to object
+      "HTTP/1.0 200 OK\r\nContent-Length: #{object.size}\r\n\r\n" + object
+    end
+  end
+end

data/spec/client_server_spec.rb

@@ -0,0 +1,107 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'socket'
+require 'timeout'
+
+describe "ClientServer", :shared => true do
+  before(:all) do
+    @tcp_server = TCPServer.new('127.0.0.1', 56000)
+  end
+
+  before do
+    @handler_errors = 0
+    $evaluate_calls = 0
+    @client = Arpie::Client.new(Arpie::MarshalProtocol.new, Arpie::SizedProtocol.new)
+    @server = Arpie::Server.new(Arpie::MarshalProtocol.new, Arpie::SizedProtocol.new)
+    @client.connect do TCPSocket.new('127.0.0.1', 56000) end
+    @server.accept do @tcp_server.accept end
+    @server.on_handler_error do |s, e, p, x|
+      @handler_errors += 1
+    end
+
+    @server.handle do |s, e, m|
+      e.write_message m
+    end
+  end
+end
+
+describe "ProxyClientServer", :shared => true do
+  before(:all) do
+    @tcp_server = TCPServer.new('127.0.0.1', 56001)
+  end
+
+  before do
+    @handler_errors = 0
+    $evaluate_calls = 0
+    @client = Arpie::ProxyClient.new(Arpie::MarshalProtocol.new, Arpie::SizedProtocol.new)
+    @server = Arpie::ProxyServer.new(Arpie::MarshalProtocol.new, Arpie::SizedProtocol.new)
+    @client.connect do TCPSocket.new('127.0.0.1', 56001) end
+    @server.accept do @tcp_server.accept end
+    @server.on_handler_error do |s, e, p, x|
+      @handler_errors += 1
+    end
+
+    @server.handle((Class.new do
+      def evaluate_calls
+        $evaluate_calls += 1
+      end
+      def raise_something
+        raise "test"
+      end
+    end).new)
+  end
+end
+
+describe Arpie::Client do
+  it_should_behave_like "ClientServer"
+end
+
+describe Arpie::EventedClient do
+  it_should_behave_like "ClientServer"
+
+  before do
+    @client = Arpie::EventedClient.new(Arpie::MarshalProtocol.new, Arpie::SizedProtocol.new)
+    @handler_calls = 0
+    @queue = Queue.new
+    @client.handle do
+      @queue.push true
+      @handler_calls += 1
+    end
+    @client.connect do TCPSocket.new('127.0.0.1', 56000) end
+  end
+
+  it "should not allow reading messages" do
+    @client.should_not respond_to :read_message
+  end
+
+  it "should call the handler for incoming messages" do
+    @client.write_message "test"
+    lambda {Timeout.timeout(1.0) { @queue.pop } }.should_not raise_error TimeoutError
+  end
+end
+
+describe Arpie::Server do
+  it_should_behave_like "ClientServer"
+end
+
+describe "ProxyServer" do
+  it_should_behave_like "ProxyClientServer"
+  it "should raise handler errors to the client" do
+    lambda { @client.raise_something }.should(raise_error RuntimeError, "Internal Error")
+    @handler_errors.should == 1
+  end
+
+  it "should not re-evaluate for already-seen uuids" do
+    @client.evaluate_calls
+    @client.evaluate_calls
+    @client.uuid_generator do 100 end
+    @client.evaluate_calls
+    @client.evaluate_calls
+    $evaluate_calls.should == 3
+  end
+
+  it "should not call handler errors for missing methods" do
+    lambda { @client.missing }.should raise_error NoMethodError
+    $evaluate_calls.should == 0
+  end
+end

data/spec/protocol_merge_and_split_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+class Splitter < Arpie::Protocol
+  def from binary
+    yield binary.size
+    binary.each_char do |c|
+      yield c
+    end
+  end
+end
+
+class Merger < Arpie::Protocol
+  def from binary
+    unless @expect
+      @expect = binary or incomplete!
+      gulp!
+    end
+
+    assemble! binary, :d, :size => @expect
+  end
+
+  def assemble binaries, token, meta
+    binaries.size >= meta[:size] or incomplete!
+    yield binaries.join('')
+  end
+end
+
+describe "Merger::Splitter::Sized" do subject { [Splitter, Arpie::SizedProtocol] }
+  it_should_behave_like "ProtocolChainSetup"
+
+  it "should split messages correctly" do
+    chain_write(t = 'test')
+    chain_read.should == t.size
+    for i in 1..t.size do
+      chain_read.should == t[i-1, 1]
+    end
+  end
+end
+
+describe "Merger::Splitter::Sized" do subject { [Merger, Splitter, Arpie::SizedProtocol] }
+  it_should_behave_like "ProtocolChainSetup"
+
+  it "should assemble split messages correctly" do
+    chain_write(t = 'test')
+    chain_read.should == t
+  end
+end

data/spec/protocol_spec.rb

@@ -0,0 +1,152 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "ProtocolChain", :shared => true do
+  it_should_behave_like "ProtocolChainSetup"
+
+  it "should convert without io correctly" do
+    v = @chain.to @testdata_a
+    @chain.from(v).should == [@testdata_a]
+  end
+
+  it "should read written binary data correctly" do
+    chain_write(@testdata_a)
+    chain_read.should == @testdata_a
+  end
+
+  it "should read multiple written messages correctly" do
+    write = []
+    for i in 0...4 do
+      write << (i % 2 == 0 ? @testdata_a : @testdata_b)
+    end
+    chain_write(*write)
+
+    for i in 0...4 do
+      chain_read.should == (i % 2 == 0 ? @testdata_a : @testdata_b)
+    end
+  end
+
+  it "should not clobber the buffer before the first read" do
+    chain_write(@testdata_a)
+  end
+
+  it "should parse a io-written buffer correctly" do
+    write = []
+    for i in 0...4 do
+      write << (i % 2 == 0 ? @testdata_a : @testdata_b)
+    end
+    chain_write(*write)
+
+    @chain.from(@r.readpartial(4096)).should == [@testdata_a, @testdata_b, @testdata_a, @testdata_b]
+  end
+
+  it "should read messages greater than MTU correctly" do
+    chain_write(message = (@testdata_a * (Arpie::MTU + 10)))
+    chain_read.should == message
+  end
+
+  it "should not fail on interleaved io streams" do
+    r2, w2 = IO.pipe
+    chain_write(@testdata_a)
+    @chain.write_message(w2, @testdata_b)
+    w2.close
+    chain_read.should == @testdata_a
+    @chain.read_message(r2).should == @testdata_b
+  end
+end
+
+describe "ObjectProtocolChain", :shared => true do
+  it_should_behave_like "ProtocolChain"
+  # Now, lets try some variations.
+
+  it "should read written objects correctly" do
+    chain_write(
+      a = [1, 2.4, false, true, nil, "string"],
+      b = {1 => "hi", 2 => "test", 3 => "bloh"}
+    )
+
+    chain_read.should == a
+    chain_read.should == b
+  end
+end
+
+describe "RPCProtocolChain", :shared => true do
+  it_should_behave_like "RPCProtocolChainSetup"
+
+  it "should send namespace-less RPC calls correctly encoded" do
+    call = Arpie::RPCall.new(nil, 'meth', [1, 2, 3])
+    @client.write_message(@w, call)
+    @w.close
+    @server.read_message(@r).should == call
+  end
+
+  it "should send namespaced RPC calls correctly encoded" do
+    call = Arpie::RPCall.new('ns', 'meth', [1, 2, 3])
+    @client.write_message(@w, call)
+    @w.close
+    @server.read_message(@r).should == call
+  end
+
+  it "should encode result values correctly" do
+    for r in inp = [1, 2.4, false, true, "string", {"1"=>"hash"}, [1,2,3]]
+      @server.write_message(@w, r)
+    end
+    @w.close
+
+    for r in inp
+      @client.read_message(@r).should == r
+    end
+  end
+end
+
+# Now, lets try some variations.
+
+describe "Sized" do subject { [Arpie::SizedProtocol] }
+  it_should_behave_like "ProtocolChain"
+end
+
+describe "Sized::Sized" do subject { [Arpie::SizedProtocol, Arpie::SizedProtocol] }
+  it_should_behave_like "ProtocolChain"
+end
+
+describe "Sized::Marshal::Sized" do subject { [Arpie::SizedProtocol, Arpie::MarshalProtocol, Arpie::SizedProtocol] }
+  it_should_behave_like "ProtocolChain"
+end
+
+# Shellwords is a bit of a special case, because it only encodes arrays.
+describe "Shellwords::Separator" do subject { [Arpie::ShellwordsProtocol, Arpie::SeparatorProtocol] }
+  it_should_behave_like "ProtocolChain"
+  before do
+    @testdata_a, @testdata_b = ['I am test', '1'], ['I am test', '2']
+  end
+end
+
+describe "HTTPTest" do subject { [Arpie::HTTPClientTestProtocol] }
+  it_should_behave_like "ProtocolChain"
+end
+
+describe "HTTPTest" do subject { [Arpie::HTTPServerTestProtocol] }
+  it_should_behave_like "ProtocolChain"
+end
+
+describe "YAML" do subject { [Arpie::YAMLProtocol] }
+  it_should_behave_like "ObjectProtocolChain"
+end
+
+describe "XMLRPC::Sized" do subject {
+    [
+      [Arpie::XMLRPCClientProtocol, Arpie::SizedProtocol],
+      [Arpie::XMLRPCServerProtocol, Arpie::SizedProtocol]
+    ]
+  }
+  it_should_behave_like "RPCProtocolChain"
+end
+
+describe "XMLRPC::HTTPTest" do subject {
+    [
+      [Arpie::XMLRPCClientProtocol, Arpie::HTTPClientTestProtocol],
+      [Arpie::XMLRPCServerProtocol, Arpie::HTTPServerTestProtocol]
+    ]
+  }
+  it_should_behave_like "RPCProtocolChain"
+end
+