RubyGems - marilyn-rpc - Versions diffs - 0.0.3 → 0.0.4 - Mend

marilyn-rpc 0.0.3 → 0.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

data/benchmark/client.rb +42 -14
data/doc/MarilynRPC.html +108 -0
data/doc/MarilynRPC/CallRequestMail.html +578 -0
data/doc/MarilynRPC/CallResponseMail.html +418 -0
data/doc/MarilynRPC/Envelope.html +705 -0
data/doc/MarilynRPC/ExceptionMail.html +338 -0
data/doc/MarilynRPC/Gentleman.html +658 -0
data/doc/MarilynRPC/MailFactory.html +284 -0
data/doc/MarilynRPC/MailHelper.html +489 -0
data/doc/MarilynRPC/NativeClient.html +579 -0
data/doc/MarilynRPC/NativeClientProxy.html +303 -0
data/doc/MarilynRPC/Server.html +406 -0
data/doc/MarilynRPC/Service.html +599 -0
data/doc/MarilynRPC/ServiceCache.html +481 -0
data/doc/_index.html +219 -0
data/doc/class_list.html +36 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +53 -0
data/doc/css/style.css +318 -0
data/doc/file.README.html +154 -0
data/doc/file_list.html +38 -0
data/doc/frames.html +13 -0
data/doc/index.html +154 -0
data/doc/js/app.js +203 -0
data/doc/js/full_list.js +149 -0
data/doc/js/jquery.js +16 -0
data/doc/method_list.html +467 -0
data/doc/top-level-namespace.html +88 -0
data/lib/marilyn-rpc/client.rb +20 -21
data/lib/marilyn-rpc/envelope.rb +27 -10
data/lib/marilyn-rpc/gentleman.rb +8 -1
data/lib/marilyn-rpc/mails.rb +40 -55
data/lib/marilyn-rpc/server.rb +4 -11
data/lib/marilyn-rpc/service.rb +1 -1
data/lib/marilyn-rpc/service_cache.rb +7 -4
data/lib/marilyn-rpc/version.rb +1 -1
data/marilyn-rpc-0.0.2.gem +0 -0
data/spec/envelope_spec.rb +18 -9
data/spec/gentleman_spec.rb +14 -3
data/spec/mails_spec.rb +2 -1
data/spec/server_spec.rb +4 -4
data/spec/service_cache_spec.rb +8 -0
data/spec/spec_helper.rb +9 -2
metadata +30 -22

data/doc/top-level-namespace.html ADDED

@@ -0,0 +1,88 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>Top Level Namespace</title>
+<link rel="stylesheet" href="css/style.css" type="text/css" media="screen" charset="utf-8" />
+<link rel="stylesheet" href="css/common.css" type="text/css" media="screen" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  relpath = '';
+  if (relpath != '') relpath += '/';
+</script>
+<script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+<script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <script type="text/javascript" charset="utf-8">
+      if (window.top.frames.main) document.body.className = 'frames';
+    </script>
+    <div id="header">
+      <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
+</div>
+      <div id="search">
+  <a id="class_list_link" href="#">Class List</a>
+  <a id="method_list_link" href="#">Method List</a>
+  <a id ="file_list_link" href="#">File List</a>
+</div>
+      <div class="clear"></div>
+    </div>
+    <iframe id="search_frame"></iframe>
+    <div id="content"><h1>Top Level Namespace
+</h1>
+<dl class="box">
+</dl>
+<div class="clear"></div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="MarilynRPC.html" title="MarilynRPC (module)">MarilynRPC</a></span>
+</p>
+</div>
+    <div id="footer">
+  Generated on Wed Jun  8 18:26:47 2011 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.6.8 (ruby-1.8.7).
+</div>
+  </body>
+</html>

data/lib/marilyn-rpc/client.rb CHANGED

@@ -4,7 +4,7 @@ require 'thread'
 module MarilynRPC
   # A class with nothing but `__send__` and `__id__`
   class ClientBlankSlate
-    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+    instance_methods.each { |m| undef_method m unless m =~ /^__|object_id/ }
   end
   class NativeClientProxy < ClientBlankSlate
@@ -32,29 +32,31 @@ module MarilynRPC
   #   TestService.time.to_f
   #
   class NativeClient
+    MAIL_KEY = :_mlynml
     # Create a native client for the socket.
     # @param [Socket] socket the socket to manage
     def initialize(socket)
       @socket = socket
       @semaphore = Mutex.new
       @threads = {}
-      @responses = {}
       @thread = Thread.new do
+        # read the answer of the server back in
+        envelope = MarilynRPC::Envelope.new
         loop do
-          # read the answer of the server back in
-          answer = MarilynRPC::Envelope.new
           # read the header to have the size
-          answer.parse!(@socket.read(4))
-          # so now that we know the site, read the rest of the envelope
-          answer.parse!(@socket.read(answer.size))
+          envelope.parse_header! @socket.read(MarilynRPC::Envelope::HEADER_SIZE)
+          # so now that we know the site, read the rest of the envelope without
+          # parsing
+          envelope.content = @socket.read(envelope.size)
           # returns the result part of the mail or raise the exception if there is
           # one
-          mail = MarilynRPC::MailFactory.unpack(answer)
-          @semaphore.synchronize do
-            @responses[mail.tag] = mail # save the mail for the waiting thread
-            @threads.delete(mail.tag).wakeup # wake up the waiting thread
-          end
+          mail = MarilynRPC::MailFactory.unpack(envelope)
+          thread = @semaphore.synchronize { @threads.delete(mail.tag) }
+          thread[MAIL_KEY] = mail # save the mail for the waiting thread
+          thread.wakeup # wake up the waiting thread
+          envelope.reset!
         end
       end
     end
@@ -129,23 +131,20 @@ module MarilynRPC
       thread = Thread.current
       tag = "#{Time.now.to_f}:#{thread.object_id}"
-      @semaphore.synchronize do
+      @semaphore.synchronize {
         # since this client can't multiplex, we set the tag to nil
         @socket.write(MarilynRPC::MailFactory.build_call(tag, path, method, args))
-      end
-      # lets write our self to the list of waining threads
-      @semaphore.synchronize { @threads[tag] = thread }
-      # enable the listening for a response from the remote end
-      @thread.wakeup
+        # lets write our self to the list of waining threads
+        @threads[tag] = thread
+      }
       # stop the current thread, the thread will be started after the response
       # arrived
       Thread.stop
       # get mail from responses
-      mail = @semaphore.synchronize { @responses.delete(tag) }
+      mail = thread[MAIL_KEY]
       if mail.is_a? MarilynRPC::CallResponseMail
         mail.result

data/lib/marilyn-rpc/envelope.rb CHANGED

@@ -1,13 +1,26 @@
 # This class handles the envelope parsing and encoding which will be used by the
 # server to handle multiple writes into the envelope.
 class MarilynRPC::Envelope
+  HEADER_SIZE = 5
+  HEADER_ENCODING = "NC".freeze
   # size of the envelope content
   attr_reader :size
+  # the type of mail that is in the envelope
+  attr_accessor :type
   # create a new envelope instance
   # @param [String] content the content of the new envelope
-  def initialize(content = nil)
+  # @param [String] type the type of content
+  def initialize(content = nil, type = nil)
     self.content = content
+    @type = type
+  end
+  # resets the envelope object to contain no data, like if it was newly created
+  def reset!
+    @buffer, @size, @type = "", nil, nil
   end
   # parses the passed data
@@ -17,20 +30,24 @@ class MarilynRPC::Envelope
   #   In case there are no data it will return nil.
   def parse!(data)
     @buffer += data
-    overhang = nil
     # parse the length field of the
-    if @size.nil? && @buffer.size >= 4
-      # extract 4 bytes length header
-      @size = @buffer.slice!(0...4).unpack("N").first
+    if @size == nil && @buffer.size >= HEADER_SIZE
+      parse_header!(@buffer.slice!(0...HEADER_SIZE))
     end
     # envelope is complete and contains overhang
-    if !@size.nil? && @buffer.size > @size
-      overhang = @buffer.slice!(@size, @buffer.size)
+    if @size && @buffer.size > @size
+      return @buffer.slice!(@size, @buffer.size) # returns the overhang
     end
-    overhang
+  end
+  # parses the header without having much checking overhead. This is useful in
+  # situations where we can assure the size beforehand
+  # @param [String] header the header byte string of size {HEADER_SIZE}
+  # @api private
+  def parse_header!(header)
+    @size, @type = header.unpack(HEADER_ENCODING)
   end
   # returns the content of the envelope
@@ -51,7 +68,7 @@ class MarilynRPC::Envelope
   # encodes the envelope to be send over the wire
   # @return [String] encoded envelope
   def encode
-    [@size].pack("N") + @buffer
+    [@size, @type].pack(HEADER_ENCODING) + @buffer
   end
   # checks if the complete envelope was allready parsed

data/lib/marilyn-rpc/gentleman.rb CHANGED

@@ -54,7 +54,14 @@ class MarilynRPC::Gentleman
   # @api private
   def handle(*args)
     mail = MarilynRPC::CallResponseMail.new(self.tag, self.callback.call(*args))
-    connection.send_mail(mail)
+    data = MarilynRPC::Envelope.new(mail.encode,
+                                    MarilynRPC::CallResponseMail::TYPE).encode
+    connection.send_data(data)
+  rescue Exception => exception
+    mail = MarilynRPC::ExceptionMail.new(self.tag, exception)
+    data = MarilynRPC::Envelope.new(mail.encode,
+                                    MarilynRPC::ExceptionMail::TYPE).encode
+    connection.send_data(data)
   end
   # The helper that will be called by the deferable to call

data/lib/marilyn-rpc/mails.rb CHANGED

@@ -1,101 +1,86 @@
 module MarilynRPC
   # Helper that gets mixed into the mail classes to make common things easyer
   module MailHelper
-    # generate a new serialize id which can be used in a mail
-    # @param [Integer] a number between 0 and 254
-    # @param [String] returns an 1 byte string as type id
-    def self.type(nr)
-      [nr].pack("c")
-    end
-    # extracts the real data and ignores the type information
-    # @param [String] data the data to extract the mail from
-    # @return [String] the extracted data
-    def only_data(data)
-      data.slice(1, data.size)
-    end
-    # serialize the data using marilyns default serializer
-    # @param [Object] data the data to encode
-    # @param [String] the serialized data
-    def serialize(data)
-      Marshal.dump(data)
-    end
-    # deserializes the passed data to the original objects
-    # @param [String] data the serialized data
-    # @return [Object] the deserialized object
-    def deserialize(data)
-      Marshal.load(data)
-    end
+    SERIALIZER = Marshal
   end
   class CallRequestMail < Struct.new(:tag, :path, :method, :args)
     include MarilynRPC::MailHelper
-    TYPE = MarilynRPC::MailHelper.type(1)
+    TYPE = 1
     def encode
-      TYPE + serialize([self.tag, self.path, self.method, self.args])
+      SERIALIZER.dump([self.tag, self.path, self.method, self.args])
     end
     def decode(data)
-      self.tag, self.path, self.method, self.args = deserialize(only_data(data))
+      self.tag, self.path, self.method, self.args = SERIALIZER.load(data)
     end
   end
   class CallResponseMail < Struct.new(:tag, :result)
     include MarilynRPC::MailHelper
-    TYPE = MarilynRPC::MailHelper.type(2)
+    TYPE = 2
     def encode
-      TYPE + serialize([self.tag, self.result])
+      SERIALIZER.dump([self.tag, self.result])
     end
     def decode(data)
-      self.tag, self.result = deserialize(only_data(data))
+      self.tag, self.result = SERIALIZER.load(data)
     end
   end
   class ExceptionMail < Struct.new(:tag, :exception)
     include MarilynRPC::MailHelper
-    TYPE = MarilynRPC::MailHelper.type(3)
+    TYPE = 3
     def encode
-      TYPE + serialize([self.tag, self.exception])
+      SERIALIZER.dump([self.tag, self.exception])
     end
     def decode(data)
-      self.tag, self.exception = deserialize(only_data(data))
+      self.tag, self.exception = SERIALIZER.load(data)
     end
   end
   # Helper to destiguish between the different mails
   module MailFactory
+    include MarilynRPC::MailHelper
+    # table which contains all types that can be unpacked
+    TYPE_LOOK_UP = {
+      MarilynRPC::CallRequestMail::TYPE   => MarilynRPC::CallRequestMail,
+      MarilynRPC::CallResponseMail::TYPE  => MarilynRPC::CallResponseMail,
+      MarilynRPC::ExceptionMail::TYPE     => MarilynRPC::ExceptionMail
+    }
     # Parses the envelop and generate the correct mail.
     # @param [MarilynRPC::Envelope] envelope the envelope which contains a mail
     # @return [MarilynRPC::CallRequestMail, MarilynRPC::CallResponseMail,
     #          MarilynRPC::ExceptionMail] the mail object that was extracted
-    def self.unpack(envelope)
-      data = envelope.content
-      type = data.slice(0, 1)
-      case type
-        when MarilynRPC::CallRequestMail::TYPE
-          mail = MarilynRPC::CallRequestMail.new
-        when MarilynRPC::CallResponseMail::TYPE
-          mail = MarilynRPC::CallResponseMail.new
-        when MarilynRPC::ExceptionMail::TYPE
-          mail = MarilynRPC::ExceptionMail.new
-        else
-          raise MarilynRPC::BrokenEnvelopeError.new("The passed envelope is broken!")
-      end
-      mail.decode(data)
-      mail
+    def self.unpack(envelope)
+      if mail_klass = TYPE_LOOK_UP[envelope.type]
+        mail = mail_klass.new(*SERIALIZER.load(envelope.content))
+      else
+        raise MarilynRPC::BrokenEnvelopeError.new \
+          "The passed envelope is broken, no (correct) type!"
+      end
     end
-    # builds the binary data for a method call
-    def self.build_call(tag, path, method_name, args)
-      mail = MarilynRPC::CallRequestMail.new(tag, path, method_name, args)
-      MarilynRPC::Envelope.new(mail.encode).encode
+    # builds the binary data for a method call, it inlines some of the packing
+    # for performance critical applications.
+    # @param [Object] tag the tag for the object is relevate for multuplexing,
+    #   it should be unique on a per conncetion base
+    # @param [Object] path the path to identifiy the service
+    # @param [Symbol, String] method the method name to call on the service
+    # @param [Array<Object>] args the arguments that are passed to the remote
+    #   side
+    # @return [Object] the result of the call
+    def self.build_call(tag, path, method, args)
+      data = MarilynRPC::MailHelper::SERIALIZER.dump([tag, path, method, args])
+      [
+        data.size, MarilynRPC::CallRequestMail::TYPE
+      ].pack(MarilynRPC::Envelope::HEADER_ENCODING) + data
     end
   end
 end

data/lib/marilyn-rpc/server.rb CHANGED

@@ -36,25 +36,18 @@ module MarilynRPC::Server
     if @envelope.finished?
       # grep the request
       answer = @cache.call(@envelope)
-      if answer.is_a? MarilynRPC::Gentleman
+      if answer.is_a? String
+        send_data(answer)
+      else
         answer.connection = self # pass connection for async responses
-      else
-        send_mail(answer)
       end
       # initialize the next envelope
-      @envelope = MarilynRPC::Envelope.new
+      @envelope.reset!
       receive_data(overhang) if overhang # reenter the data loop
     end
   end
-  # Send a response mail back on the wire of buffer
-  # @param [MarilynRPC::ExceptionMail, MarilynRPC::CallResponseMail] mail the
-  #   mail that should be send to the client
-  def send_mail(mail)
-    send_data(MarilynRPC::Envelope.new(mail.encode).encode)
-  end
   # Handler for client disconnect
   def unbind
     @cache.disconnect!

data/lib/marilyn-rpc/service.rb CHANGED

@@ -1,6 +1,6 @@
 # A class with nothing but `__send__`, `__id__`, `class` and `public_methods`.
 class ServiceBlankSlate
-  instance_methods.each { |m| undef_method m unless m =~ /^__|public_methods|class/ }
+  instance_methods.each { |m| undef_method m unless m =~ /^__|public_methods|class|object_id/ }
 end
 # This class represents the base for all events, it is used for registering

data/lib/marilyn-rpc/service_cache.rb CHANGED

@@ -36,18 +36,21 @@ class MarilynRPC::ServiceCache
       if result.is_a? MarilynRPC::Gentleman
         result.tag = tag # set the correct mail tag for the answer
         result
-      else
-        MarilynRPC::CallResponseMail.new(tag, result) # direct response
+      else # direct response
+        MarilynRPC::Envelope.new(MarilynRPC::CallResponseMail.new(tag, result).encode,
+                                 MarilynRPC::CallResponseMail::TYPE).encode
       end
     else
       raise MarilynRPC::BrokenEnvelopeError.new("Expected CallRequestMail Object!")
     end
   rescue MarilynRPC::BrokenEnvelopeError => exception
-    MarilynRPC::ExceptionMail.new(nil, exception)
+    MarilynRPC::Envelope.new(MarilynRPC::ExceptionMail.new(nil, exception).encode,
+                             MarilynRPC::ExceptionMail::TYPE).encode
   rescue => exception
     #puts exception
     #puts exception.backtrace.join("\n   ")
-    MarilynRPC::ExceptionMail.new(tag, exception)
+    MarilynRPC::Envelope.new(MarilynRPC::ExceptionMail.new(tag, exception).encode,
+                             MarilynRPC::ExceptionMail::TYPE).encode
   end
   # get the service from the cache or the service registry