marilyn-rpc 0.0.1 → 0.0.2

data/lib/marilyn-rpc/client.rb

@@ -1,35 +1,23 @@
 require 'socket'
+require 'thread'
 
 module MarilynRPC
-  class NativeClientProxy
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
+  
+  class NativeClientProxy < BlankSlate
     # Creates a new Native client proxy, were the calls get send to the remote
     # side.
     # @param [Object] path the path that is used to identify the service
-    # @param [Socekt] socket the socket to use for communication
-    def initialize(path, socket)
-      @path, @socket = path, socket
+    # @param [NativeClient] client the client to use for communication
+    def initialize(path, client)
+      @path, @client = path, client
     end
 
     # Handler for calls to the remote system
     def method_missing(method, *args, &block)
-      # since this client can't multiplex, we set the tag to nil
-      @socket.write(MarilynRPC::MailFactory.build_call(nil, @path, method, args))
-
-      # 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))
-
-      # returns the result part of the mail or raise the exception if there is 
-      # one
-      mail = MarilynRPC::MailFactory.unpack(answer)
-      if mail.is_a? MarilynRPC::CallResponseMail
-        mail.result
-      else
-        raise mail.exception
-      end
+      @client.execute(@path, method, args)
     end
   end
 
@@ -47,6 +35,27 @@ module MarilynRPC
     # @param [Socket] socket the socket to manage
     def initialize(socket)
       @socket = socket
+      @semaphore = Mutex.new
+      @threads = {}
+      @responses = {}
+      @thread = Thread.new do
+        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))
+
+          # 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
+        end
+      end
     end
 
     # Disconnect the client from the remote.
@@ -60,7 +69,7 @@ module MarilynRPC
     # @return [MarilynRPC::NativeClientProxy] the proxy obejct that will serve
     #   all calls
     def for(path)
-      NativeClientProxy.new(path, @socket)
+      NativeClientProxy.new(path, self)
     end
     
     # Connect to a unix domain socket.
@@ -73,9 +82,65 @@ module MarilynRPC
     # Connect to a tcp socket.
     # @param [String] host the host to cennect to (e.g. 'localhost')
     # @param [Integer] port the port to connect to (e.g. 8000)
-    # @return [MarilynRPC::NativeClient] the cónnected client
-    def self.connect_tcp(host, port)
-      new(TCPSocket.open(host, port))
+    # @param [Hash] options the
+    # @option options [Boolean] :secure use tls/ssl for the connection
+    #   `true` or `false`
+    # @option options [OpenSSL::SSL::SSLContext] :ssl_context can be used to
+    #   change the ssl context of the newly created secure connection. Only
+    #   takes effect if `:secure` option is enabled.
+    # @return [MarilynRPC::NativeClient] the connected client
+    def self.connect_tcp(host, port, options = {})
+      if options[:secure] == true
+        require 'openssl' # use openssl for secure connections
+        socket = TCPSocket.new(host, port)
+        if ssl_context = options[:ssl_context]
+          secure_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+        else
+          secure_socket = OpenSSL::SSL::SSLSocket.new(socket)
+        end
+        secure_socket.connect
+        new(secure_socket)
+      else
+        new(TCPSocket.open(host, port))
+      end
+    end
+    
+    # Executes a client call blocking. To issue an async call one needs to
+    # have start separate threads. THe Native client uses then multiplexing to
+    # avoid the other threads blocking.
+    # @api private
+    # @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 execute(path, method, args)
+      thread = Thread.current
+      tag = "#{Time.now.to_f}:#{thread.object_id}"
+      
+      @semaphore.synchronize do
+        # 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
+      
+      # 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) }
+
+      if mail.is_a? MarilynRPC::CallResponseMail
+        mail.result
+      else
+        raise mail.exception
+      end
     end
   end
 end

data/lib/marilyn-rpc/gentleman.rb

@@ -51,12 +51,15 @@ class MarilynRPC::Gentleman
   # The handler that will send the response to the remote system
   # @param [Object] args the arguments that should be handled by the callback,
   #   the reponse of the callback will be send as result
+  # @api private
   def handle(*args)
     mail = MarilynRPC::CallResponseMail.new(self.tag, self.callback.call(*args))
     connection.send_mail(mail)
   end
   
-  # The helper that will be called by the deferable to call {handle} later
+  # The helper that will be called by the deferable to call 
+  # {MarilynRPC::Gentleman#handle} later
+  # @api private
   def helper
     gentleman = self
     lambda { |*args| gentleman.handle(*args) }

data/lib/marilyn-rpc/mails.rb

@@ -56,7 +56,7 @@ module MarilynRPC
     end
   end
   
-  class ExceptionMail < Struct.new(:exception)
+  class ExceptionMail < Struct.new(:tag, :exception)
     include MarilynRPC::MailHelper
     TYPE = MarilynRPC::MailHelper.type(3)
     

data/lib/marilyn-rpc/server.rb

@@ -1,9 +1,30 @@
+# The server will be used to make incomming connections possible. The server
+# handles the low level networking functions, so that the services don't have
+# to deal with them. Because of the way eventmachine works you can have as many
+# servers as you want.
+#
+# @example a server which is available througth 3 connections:
+#   EM.run {
+#     EM.start_server "localhost", 8000, MarilynRPC::Server
+#     EM.start_server "localhost", 8008, MarilynRPC::Server, :secure => true
+#     EM.start_unix_domain_server("tmp.socket", MarilynRPC::Server)
+#   }
+#
 module MarilynRPC::Server
+  # initalize the server with connection options
+  # @param [Hash] options the options passed to the server
+  # @option options [Boolean] :secure enable secure transfer for the server
+  #   possible values `true` or `false`
+  def initialize(options = {})
+    @secure = options[:secure]
+  end
+  
   # Initialize the first recieving envelope for the connection and create the
   # service cache since each connection gets it's own service instance.
   def post_init
     @envelope = MarilynRPC::Envelope.new
     @cache = MarilynRPC::ServiceCache.new
+    start_tls if @secure
   end
   
   # Handler for the incoming data. EventMachine compatible.
@@ -15,14 +36,15 @@ module MarilynRPC::Server
     if @envelope.finished?
       begin
         # grep the request
-        answer = @cache.call(MarilynRPC::MailFactory.unpack(@envelope))
+        mail = MarilynRPC::MailFactory.unpack(@envelope)
+        answer = @cache.call(mail)
         if answer.is_a? MarilynRPC::CallResponseMail
           send_mail(answer)
         else
           answer.connection = self # pass connection for async responses
         end
       rescue => exception
-        send_mail(MarilynRPC::ExceptionMail.new(exception))
+        send_mail(MarilynRPC::ExceptionMail.new(mail.tag, exception))
       end
       
       # initialize the next envelope
@@ -39,5 +61,7 @@ module MarilynRPC::Server
   end
   
   # Handler for client disconnect
-  def unbind; end
+  def unbind
+    @cache.disconnect!
+  end
 end

data/lib/marilyn-rpc/service.rb

@@ -1,3 +1,24 @@
+# This class represents the base for all events, it is used for registering
+# services and defining callbacks for certain service events.
+# @example a service that makes use of the available helpers
+#   class EventsService < MarilynRPC::Service
+#     register :events
+#     after_connect :connected
+#     after_disconnect :disconnected
+#   
+#     def connected
+#       puts "client connected"
+#     end
+#   
+#     def notify(msg)
+#       puts msg
+#     end
+#   
+#     def disconnected
+#       puts "client disconnected"
+#     end
+#   end
+#
 class MarilynRPC::Service
   # registers the class where is was called as a service
   # @param [String] path the path of the service
@@ -7,9 +28,52 @@ class MarilynRPC::Service
   end
   
   # returns all services, that where registered
+  # @api private
   # @return [Hash<String, Object>] all registered services with path as key and
   #   the registered service as object
   def self.registry
     @@registry || {}
   end
+  
+  # register one or more connect callbacks, a callback is simply a method
+  # defined in the class
+  # @param [Array<Symbol>, Array<String>] callbacks the method names
+  def self.after_connect(*callbacks)
+    register_callbacks :after_connect, callbacks
+  end
+  
+  # register one or more disconnect callbacks, a callback is simply a method
+  # defined in the class
+  # @param [Array<Symbol>, Array<String>] callbacks the method names
+  def self.after_disconnect(*callbacks)
+    register_callbacks :after_disconnect, callbacks
+  end
+  
+  # registers a callbacks for the service class
+  # @param [Symbol] name the name under which the callbacks should be saved
+  # @param [Array<Symbol>, Array<String>] callbacks the method names
+  # @api private
+  def self.register_callbacks(name, callbacks)
+    @_callbacks ||= {}         # initialize callbacks
+    @_callbacks[name] ||= []   # initialize specific set
+    @_callbacks[name] += callbacks
+  end
+  
+  # returns the registered callbacks for name
+  # @param [Symbol] name the name to lookup callbacks for
+  # @return [Array<String>, Array<Symbol>] an array of callback names, or an
+  #   empty array
+  # @api private
+  def self.registered_callbacks(name)
+    (@_callbacks || {})[name] || []
+  end
+  
+  # calls the defined connect callbacks
+  # @param [Symbol] the name of the callbacks to run
+  # @api private
+  def run_callbacks!(name)
+    self.class.registered_callbacks(name).each do |callback|
+      self.send(callback)
+    end
+  end
 end

data/lib/marilyn-rpc/service_cache.rb

@@ -39,9 +39,20 @@ class MarilynRPC::ServiceCache
       return service
     # it's not in the cache, so try lookup in the service registry
     elsif service = MarilynRPC::Service.registry[path]
-      return (@services[path] = service.new)
+      @services[path] = service.new
+      @services[path].run_callbacks! :after_connect
+      return @services[path]
     else
-      raise ArgumentError.new("Service #{mail.path} unknown!")
+      raise ArgumentError.new("Service #{path} unknown!")
+    end
+  end
+  
+  # issue the disconnect callbacks for all living services of this connection
+  # @node this should only be called once by the server
+  # @api private
+  def disconnect!
+    @services.each do |path, service|
+      service.run_callbacks! :after_disconnect
     end
   end
 end

data/lib/marilyn-rpc/version.rb

@@ -1,3 +1,3 @@
 module MarilynRPC
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: marilyn-rpc
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Vincent Landgraf
@@ -62,6 +62,40 @@ extra_rdoc_files: []
 files: 
 - benchmark/client.rb
 - benchmark/server.rb
+- doc/_index.html
+- doc/class_list.html
+- doc/css/common.css
+- doc/css/full_list.css
+- doc/css/style.css
+- doc/file.README.html
+- doc/file_list.html
+- doc/frames.html
+- doc/index.html
+- doc/js/app.js
+- doc/js/full_list.js
+- doc/js/jquery.js
+- doc/MarilynRPC/CallRequestMail.html
+- doc/MarilynRPC/CallResponseMail.html
+- doc/MarilynRPC/Envelope.html
+- doc/MarilynRPC/ExceptionMail.html
+- doc/MarilynRPC/Gentleman.html
+- doc/MarilynRPC/MailFactory.html
+- doc/MarilynRPC/MailHelper.html
+- doc/MarilynRPC/NativeClient.html
+- doc/MarilynRPC/NativeClientProxy.html
+- doc/MarilynRPC/Server.html
+- doc/MarilynRPC/Service.html
+- doc/MarilynRPC/ServiceCache.html
+- doc/MarilynRPC.html
+- doc/method_list.html
+- doc/top-level-namespace.html
+- examples/async/client.rb
+- examples/async/server.rb
+- examples/callbacks/client.rb
+- examples/callbacks/server.rb
+- examples/secure/client.rb
+- examples/secure/server.rb
+- kiss.png
 - lib/marilyn-rpc/client.rb
 - lib/marilyn-rpc/envelope.rb
 - lib/marilyn-rpc/gentleman.rb
@@ -71,7 +105,9 @@ files:
 - lib/marilyn-rpc/service_cache.rb
 - lib/marilyn-rpc/version.rb
 - lib/marilyn-rpc.rb
+- LICENCE
 - marilyn-rpc.gemspec
+- README.md
 - spec/envelope_spec.rb
 - spec/gentleman_spec.rb
 - spec/mails_spec.rb