arpie 0.0.6 → 0.1.0

data/lib/arpie/server.rb

@@ -1,157 +0,0 @@
-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 :protocol
-
-    def initialize protocol, io
-      @protocol, @io = protocol, io
-      @protocol.reset
-    end
-
-    def read_message
-      @protocol.read_message(@io)
-    end
-
-    def write_message message
-      @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 protocols.
-    # You will need to define a handler, and an acceptor
-    # before it becomes operational.
-    def initialize *protocols
-      @protocol = Arpie::ProtocolChain.new(*protocols)
-      @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_class.new(@protocol.clone, 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/lib/arpie/xmlrpc.rb

@@ -1,108 +0,0 @@
-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)
-
-      yield @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
-      yield 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
-      yield "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
-      yield "HTTP/1.0 200 OK\r\nContent-Length: #{object.size}\r\n\r\n" + object
-    end
-  end
-end

data/spec/client_server_spec.rb

@@ -1,107 +0,0 @@
-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.serial -= 1
-    @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/tools/benchmark.rb

@@ -1,52 +0,0 @@
-require 'rubygems'
-require 'socket'
-$:.unshift(File.join(File.dirname(__FILE__), "../lib/"))
-require 'arpie'
-require 'benchmark'
-require 'drb'
-require 'xmlrpc/server'
-require 'xmlrpc/client'
-
-class Wrap
-  def reverse x
-    x.reverse
-  end
-end
-
-include Arpie
-
-server = TCPServer.new(51210)
-
-endpoint = ProxyServer.new MarshalProtocol.new, SizedProtocol.new
-endpoint.handle Wrap.new
-
-endpoint.accept do
-  server.accept
-end
-
-$proxy = ProxyClient.new MarshalProtocol.new, SizedProtocol.new
-$proxy.connect(true) do
-  TCPSocket.new("127.0.0.1", 51210)
-end
-
-Benchmark.bm {|b|
-
-  puts ""
-  puts "native DRb"
-  drbserver = DRb.start_service nil, Wrap.new
-  drbobject = DRbObject.new nil, DRb.uri
-
-  b.report("   1") { 1.times { drbobject.reverse "benchmark" } }
-  b.report("1000") { 1000.times { drbobject.reverse "benchmark" } }
-
-  puts ""
-  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" } }
-
-  puts ""
-  puts "Arpie: proxied MarshalProtocol without replay protection"
-  $proxy.replay_protection = false
-  b.report("   1") {    1.times { $proxy.reverse "benchmark" } }
-  b.report("1000") { 1000.times { $proxy.reverse "benchmark" } }
-}

data/tools/protocol_benchmark.rb

@@ -1,42 +0,0 @@
-require 'rubygems'
-$:.unshift(File.join(File.dirname(__FILE__), "../lib/"))
-require 'socket'
-require 'arpie'
-require 'benchmark'
-
-include Arpie
-
-# Data test size.
-DATA_SIZE = 512
-
-rpc_call = RPCall.new('ns.', 'meth', [1, 2, 3, 4])
-$test_data = "a" * DATA_SIZE
-$test_data.freeze
-
-# Protocols to test:
-PROTOCOLS = [
-  [SizedProtocol.new],
-  [MarshalProtocol.new, SizedProtocol.new],
-  [YAMLProtocol.new]
-]
-
-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|
-    a ||= []
-    proto = ProtocolChain.new *p
-    r, w = IO.pipe
-
-    b.report("%-30s\n" % p.map{|x| x.class.to_s}.inspect) {
-      ITERATIONS.times do
-        proto.write_message(w, $test_data)
-        proto.read_message(r)
-      end
-    }
-  }
-}