oleganza-emrpc 0.3

data/lib/emrpc/evented_api/local_connection.rb

@@ -0,0 +1,48 @@
+module EMRPC
+  class LocalConnection
+    include ConnectionMixin
+    
+    # Helper class representing abstract connection channel.
+    class Channel
+      attr_accessor :conn12, :conn21
+      def initialize(pid1, pid2, conn12 = nil)
+        @conn21 = LocalConnection.new(pid2, pid1, self)
+        @conn12 = conn12 || LocalConnection.new(pid1, pid2, self)
+      end
+      def unbind
+        @conn12.unbind
+        @conn21.unbind
+      end
+      def connection
+        @conn12
+      end
+    end
+    
+    attr_accessor :channel
+    
+    def initialize(local_pid, remote_pid, channel = nil)
+      @channel = channel || Channel.new(local_pid, remote_pid, self)
+      @local_pid = local_pid
+      @remote_pid = local_pid.connection_established(remote_pid, self)
+    end
+    
+    def unbind
+      lpid = @local_pid
+      rpid = @remote_pid
+      @local_pid = nil
+      @remote_pid = nil
+      lpid.connection_unbind(rpid, self)
+    end
+    
+    def close_connection
+      @channel.unbind
+    end
+    alias close_connection_after_writing close_connection
+          
+    LOCALNODE_ADDRESS = 'emrpc://localnode/'.parsed_uri.freeze
+    def address
+      LOCALNODE_ADDRESS
+    end
+    
+  end # LocalConnection
+end # EMRPC

data/lib/emrpc/evented_api/pid.rb

@@ -0,0 +1,198 @@
+require 'uri'
+module EMRPC  
+  # Pid is a abbreviation for "process id". Pid represents so-called lightweight process (like in Erlang OTP)
+  # Pids can be created, connected, disconnected, spawned, killed. 
+  # When pid is created, it exists on its own.
+  # When someone connects to the pid, connection is established.
+  # When pid is killed, all its connections are unbinded.
+  
+  module Pid
+    attr_accessor :uuid, :connections, :killed, :options
+    attr_accessor :_em_server_signature, :_protocol, :_bind_address
+    include DefaultCallbacks
+    include ProtocolMapper
+    
+    # FIXME: doesn't override user-defined callbacks
+    include DebugPidCallbacks if $DEBUG 
+    
+    # shorthand for console testing
+    def self.new(*attributes)
+      # We create random global const to workaround Marshal.dump issue:
+      # >> Marshal.dump(Class.new.new)
+      #    TypeError: can't dump anonymous class #<Class:0x5b5338>
+      #
+      const_set("DynamicPidClass#{rand(2**128).to_s(16).upcase}", Class.new {
+        include Pid
+        attr_accessor(*attributes)
+      }).new
+    end
+    
+    def initialize(*args, &blk)
+      @uuid = _random_uuid
+      @options = {:uuid => @uuid}
+      _common_init
+      super(*args, &blk) rescue nil
+    end
+    
+    def spawn(cls, *args, &blk)
+      pid = cls.new(*args, &blk)
+      connect(pid)
+      pid
+    end
+  
+    def tcp_spawn(addr, cls, *args, &blk)
+      pid = spawn(cls, *args, &blk)
+      pid.bind(addr)
+      pid
+    end
+    
+    def thread_spawn(cls, *args, &blk)
+      # TODO: think about thread-safe passing messages back to sender.
+    end
+    
+    def bind(addr)
+      raise "Pid is already binded!" if @_em_server_signature
+      @_bind_address = addr.parsed_uri
+      this = self
+      @_em_server_signature = make_server_connection(@_bind_address, _protocol)  do |conn|
+        conn.local_pid = this
+        conn.address = addr
+      end
+    end
+  
+    # 1. Connect to the pid.
+    # 2. When connection is established, asks for uuid.
+    # 3. When uuid is received, triggers callback on the client.
+    # (See Protocol for details)
+    def connect(addr, connected_callback = nil, disconnected_callback = nil)
+      c = if addr.is_a?(Pid) && pid = addr
+        LocalConnection.new(self, pid)
+      else
+        this = self
+        make_client_connection(addr, _protocol)  do |conn|
+          conn.local_pid = this
+          conn.address = addr
+        end
+      end
+      c.connected_callback    = connected_callback
+      c.disconnected_callback = disconnected_callback
+      c
+    end
+    
+    def disconnect(pid, disconnected_callback = nil)
+      c = @connections[pid.uuid]
+      c.disconnected_callback = disconnected_callback if disconnected_callback
+      c.close_connection_after_writing
+    end
+    
+    def kill
+      return if @killed
+      if @_em_server_signature
+        EventMachine.stop_server(@_em_server_signature)
+      end
+      @connections.each do |uuid, conn|
+        conn.close_connection_after_writing
+      end
+      @connections.clear
+      @killed = true
+    end
+    
+    # TODO:
+    # When connecting to a spawned pid, we should transparantly discard TCP connection
+    # in favor of local connection.
+    def connection_established(pid, conn)
+      @connections[pid.uuid] ||= conn
+      __send__(conn.connected_callback, pid)
+      @connections[pid.uuid].remote_pid || pid # looks like hack, but it is not.
+    end
+
+    def connection_unbind(pid, conn)
+      @connections.delete(pid.uuid)
+      __send__(conn.disconnected_callback, pid)
+    end
+    
+    #
+    # Util
+    # 
+    def options=(opts)
+      @options = opts
+      @options[:uuid] = @uuid
+      @options
+    end
+    
+    def killed?
+      @killed
+    end
+        
+    def find_pid(uuid)
+      return self if uuid == @uuid
+      ((conn = @connections[uuid]) and conn.remote_pid) or raise "Pid #{_uid} was not found in a #{self.inspect}"
+    end
+
+    def marshal_dump
+      @uuid
+    end
+    
+    def marshal_load(uuid)
+      _common_init
+      @uuid = uuid
+    end
+        
+    def connection_uuids
+      (@connections || {}).keys
+    end
+    
+    def pid_class_name
+      "Pid"
+    end
+    
+    def inspect
+      return "#<#{pid_class_name}:#{_uid} KILLED>" if @killed
+      "#<#{pid_class_name}:#{_uid} connected to #{connection_uuids.map{|u|_uid(u)}.inspect}>"
+    end
+  
+    def ==(other)
+      other.is_a?(Pid) && other.uuid == @uuid
+    end
+    
+    # shorter uuid for pretty output
+    def _uid(uuid = @uuid)
+      uuid && uuid[0,6]
+    end
+  
+    #
+    # Private, but accessible from outside methods are prefixed with underscore.
+    #
+    
+    def _protocol
+      @_protocol ||= self.__send__(:_protocol=, RemoteConnection)
+    end
+    
+    def _protocol=(p)
+      @_protocol = Util.combine_modules(
+        p, 
+        MarshalProtocol.new(Marshal), 
+        FastMessageProtocol, 
+        $DEBUG ? DebugConnection : Module.new
+      )
+    end
+    
+    # TODO: remove this in favor of using codec.rb
+    def _send_dirty(*args)
+      args._initialize_pids_recursively_d4d309bd!(self)
+      send(*args)
+    end
+    
+  private
+
+    def _common_init
+      @connections = {} # pid.uuid -> connection
+    end
+    
+    def _random_uuid
+      # FIXME: insert real uuid generating here!
+      rand(2**128).to_s(16)
+    end
+    
+  end # Pid
+end # EMRPC

data/lib/emrpc/evented_api/protocol_mapper.rb

@@ -0,0 +1,57 @@
+module EMRPC
+  module ProtocolMapper
+    #
+    # Configuration
+    #
+    MAP = Hash.new
+    
+    def self.register_protocol(scheme, suffix)
+      MAP[scheme] = suffix
+      self
+    end
+    
+    # Default mapping
+    register_protocol "emrpc",      :emrpc_tcp
+    register_protocol "unix",       :emrpc_unix
+    register_protocol "emrpc+unix", :emrpc_unix
+    register_protocol "http",       :http_json
+    
+    #
+    # Abstract API
+    # 
+    def make_client_connection(*args, &blk)
+      make_some_connection(:client, *args, &blk)
+    end
+    
+    def make_server_connection(*args, &blk)
+      make_some_connection(:server, *args, &blk)
+    end
+    
+  private
+    def make_some_connection(sfx, addr, handler, &blk)
+      addr = addr.parsed_uri
+      pfx = MAP[addr.scheme]
+      __send__("#{pfx}_#{sfx}_connection", addr, handler, &blk)
+    end
+    
+    #
+    # Particular protocols
+    #
+    def emrpc_tcp_client_connection(addr, handler, &blk)
+      EventMachine.connect(addr.host, addr.port, handler, &blk)
+    end
+
+    def emrpc_tcp_server_connection(addr, handler, &blk)
+      EventMachine.start_server(addr.host, addr.port, handler, &blk)
+    end
+    
+    def emrpc_unix_client_connection(addr, handler, &blk)
+      EventMachine.connect_unix_domain(addr.path, handler, &blk)
+    end
+
+    def emrpc_unix_server_connection(addr, handler, &blk)
+      EventMachine.start_unix_domain_server(addr.path, handler, &blk)
+    end
+    
+  end # ProtocolMapper
+end # EMRPC

data/lib/emrpc/evented_api/reconnecting_pid.rb

@@ -0,0 +1,105 @@
+module EMRPC
+  # ReconnectingPid collects all messages in the backlog buffer and tries to reconnect.
+  # Calls self.on_raise() with the following exceptions:
+  # * 
+  #
+  class ReconnectingPid
+    include Pid
+    
+    DEFAULT_MAX_BACKLOG  = 256
+    DEFAULT_MAX_ATTEMPTS = 5
+    DEFAULT_TIMEOUT      = 5 # sec.
+    DEFAULT_TIMER        = Timers::EVENTED
+    
+    # Arguments:
+    #   address          Address if a pid or the pid itself to connect to.
+    #
+    # Options:
+    #   :max_backlog     Maximum backlog size. BacklogError is raised when backlog becomes larger than 
+    #                    the specified size. Default is 256 messages.
+    #
+    #   :max_attempts    Maximum number of connection attempts. AttemptsError is raised when this number is exceeded.
+    #                    Counter is set to zero after each successful connection. Default is 5 attempts.
+    #
+    #   :timeout         Time interval in seconds. TimeoutError is raised when connection was not established
+    #                    in the specified amount of time. Default is 5 seconds.
+    #
+    #   :timer           Proc which runs a periodic timer. Default is Timers::EVENTED. See EMRPC::Timers for more info.
+    #   
+    def initialize(address, options = {})
+      super(address, options)
+      
+      @address = address
+
+      # Options
+      
+      @max_backlog    = options[:max_backlog]  || DEFAULT_MAX_BACKLOG
+      @max_attempts   = options[:max_attempts] || DEFAULT_MAX_ATTEMPTS
+      @timeout        = options[:timeout]      || DEFAULT_TIMEOUT
+      @timer          = options[:timer]        || DEFAULT_TIMER
+      
+      # Gentlemen, start your engines!
+      
+      @attempts = 1
+      @backlog  = Array.new
+      @timeout_thread = @timer.call([ @timeout, 1 ].max, method(:timer_action))
+      connect(address)
+    end
+    
+    def send(*args)
+      if rpid = @rpid
+        rpid.send(*args)
+      else
+        @backlog.push(args)
+        if @backlog.size > @max_backlog
+          on_raise(self, BacklogError.new("Backlog exceeded maximum size of #{@max_backlog} messages"))
+        end
+      end
+    end
+    
+    def flush!
+      while args = @backlog.shift
+        send(*args)
+      end
+    end
+    
+    def connected(rpid)
+      @rpid = rpid
+      @attempts = 1
+      flush!
+    end
+    
+    def disconnected(rpid)
+      @rpid = nil
+      connect(@address) unless killed?
+    end
+    
+    def connection_failed(conn)
+      a = (@attempts += 1)
+      if a > @max_attempts
+        on_raise(self, AttemptsError.new("Maximum number of #{@max_attempts} connecting attempts exceeded"))
+      end
+      connect(@address)
+    end
+    
+    def timer_action
+      if @rpid 
+        @state = nil
+        return
+      end
+      
+      if @state == :timeout
+        @state = nil
+        on_raise(self, TimeoutError.new("Failed to reconnect with #{@timeout} sec. timeout"))
+      else
+        @state = :timeout
+      end
+    end
+          
+    class ReconnectingError < StandardError; end
+    class BacklogError      < ReconnectingError; end
+    class AttemptsError     < ReconnectingError; end
+    class TimeoutError      < ReconnectingError; end
+    
+  end # ReconnectingPid
+end # EMRPC

data/lib/emrpc/evented_api/remote_connection.rb

@@ -0,0 +1,73 @@
+module EMRPC
+  module RemoteConnection
+    include ConnectionMixin
+    attr_accessor :address
+    
+    #
+    # IMPORTANT: server doesn't trigger #connection_completed callback.
+    #     
+    def post_init
+      # setup single-shot version of receive_marshalled_message
+      class <<self
+        alias_method :receive_marshalled_message, :receive_handshake_message
+      end
+    end
+    
+    #
+    # Handshake protocol
+    #
+    def connection_completed
+      send_handshake_message(@local_pid.options)
+    end
+    
+    def send_handshake_message(arg)
+      @__sent_handshake = true
+      send_marshalled_message([:handshake, arg])
+    end
+    
+    def receive_handshake_message(msg)
+      prefix, options = msg
+      lpid = @local_pid
+      prefix == :handshake or return lpid.handshake_failed(self, msg)
+      rpid = RemotePid.new(self, options)
+      # restore receive_marshalled_message
+      class <<self
+        alias_method :receive_marshalled_message, :receive_regular_message
+      end
+      unless @__sent_handshake # server-side
+        send_handshake_message(@local_pid.options)
+      end
+      @remote_pid = lpid.connection_established(rpid, self)
+    end
+    
+    #
+    # Regular protocol
+    #
+    def send_raw_message(args)
+      send_marshalled_message(args.encode_b381b571_1ab2_5889_8221_855dbbc76242(@local_pid))
+    end
+    
+    def receive_regular_message(msg)
+      lpid = @local_pid
+      lpid.__send__(*(msg.decode_b381b571_1ab2_5889_8221_855dbbc76242(lpid)))
+    end
+    
+    def rescue_marshal_error(e)
+      raise e
+    end
+    
+    def unbind
+      if @remote_pid
+        # pid has been succesfully connected one day, but connection was lost.
+        # we don't put +_unregister_pid+ into +connection_lost+ callback to avoid unneccessary +super+ calls in callbacks.
+        rpid = @remote_pid
+        @remote_pid = nil
+        @local_pid.connection_unbind(rpid, self)
+      else
+        # there were no connection, connecting failed. 
+        @local_pid.connection_failed(self)
+      end
+    end
+    
+  end # RemoteConnection
+end # EMRPC